comparison gcc/toplev.c @ 16:04ced10e8804

gcc 7
author kono
date Fri, 27 Oct 2017 22:46:09 +0900
parents f6334be47118
children 84e7813d76e9
comparison
equal deleted inserted replaced
15:561a7518be6b 16:04ced10e8804
1 /* Top level of GCC compilers (cc1, cc1plus, etc.) 1 /* Top level of GCC compilers (cc1, cc1plus, etc.)
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
5 3
6 This file is part of GCC. 4 This file is part of GCC.
7 5
8 GCC is free software; you can redistribute it and/or modify it under 6 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free 7 the terms of the GNU General Public License as published by the Free
25 Error messages and low-level interface to malloc also handled here. */ 23 Error messages and low-level interface to malloc also handled here. */
26 24
27 #include "config.h" 25 #include "config.h"
28 #include "system.h" 26 #include "system.h"
29 #include "coretypes.h" 27 #include "coretypes.h"
30 #include "tm.h" 28 #include "backend.h"
31 #include "line-map.h" 29 #include "target.h"
32 #include "input.h" 30 #include "rtl.h"
33 #include "tree.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 "varasm.h"
45 #include "tree-inline.h"
34 #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */ 46 #include "realmpfr.h" /* For GMP/MPFR/MPC versions, in print_version. */
35 #include "version.h" 47 #include "version.h"
36 #include "rtl.h"
37 #include "tm_p.h"
38 #include "flags.h" 48 #include "flags.h"
39 #include "insn-attr.h" 49 #include "insn-attr.h"
40 #include "insn-config.h"
41 #include "insn-flags.h"
42 #include "hard-reg-set.h"
43 #include "recog.h"
44 #include "output.h" 50 #include "output.h"
45 #include "except.h"
46 #include "function.h"
47 #include "toplev.h" 51 #include "toplev.h"
48 #include "expr.h" 52 #include "expr.h"
49 #include "basic-block.h"
50 #include "intl.h" 53 #include "intl.h"
51 #include "ggc.h"
52 #include "graph.h"
53 #include "regs.h"
54 #include "timevar.h"
55 #include "diagnostic.h"
56 #include "tree-diagnostic.h" 54 #include "tree-diagnostic.h"
57 #include "tree-pretty-print.h"
58 #include "params.h" 55 #include "params.h"
59 #include "reload.h" 56 #include "reload.h"
60 #include "ira.h" 57 #include "lra.h"
61 #include "dwarf2asm.h" 58 #include "dwarf2asm.h"
62 #include "integrate.h"
63 #include "debug.h" 59 #include "debug.h"
64 #include "target.h" 60 #include "common/common-target.h"
65 #include "langhooks.h" 61 #include "langhooks.h"
66 #include "cfglayout.h" 62 #include "cfgloop.h" /* for init_set_costs */
67 #include "cfgloop.h"
68 #include "hosthooks.h" 63 #include "hosthooks.h"
69 #include "cgraph.h"
70 #include "opts.h" 64 #include "opts.h"
71 #include "opts-diagnostic.h" 65 #include "opts-diagnostic.h"
72 #include "coverage.h" 66 #include "stringpool.h"
73 #include "value-prof.h" 67 #include "attribs.h"
74 #include "alloc-pool.h" 68 #include "asan.h"
75 #include "tree-mudflap.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 "ipa-prop.h"
79 #include "gcse.h"
80 #include "tree-chkp.h"
81 #include "omp-offload.h"
82 #include "hsa-common.h"
83 #include "edit-context.h"
76 #include "tree-pass.h" 84 #include "tree-pass.h"
77 #include "gimple.h" 85 #include "dumpfile.h"
78 #include "tree-ssa-alias.h"
79 #include "plugin.h"
80
81 #if defined (DWARF2_UNWIND_INFO) || defined (DWARF2_DEBUGGING_INFO)
82 #include "dwarf2out.h"
83 #endif
84 86
85 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO) 87 #if defined(DBX_DEBUGGING_INFO) || defined(XCOFF_DEBUGGING_INFO)
86 #include "dbxout.h" 88 #include "dbxout.h"
87 #endif 89 #endif
88 90
89 #ifdef SDB_DEBUGGING_INFO
90 #include "sdbout.h" 91 #include "sdbout.h"
91 #endif
92 92
93 #ifdef XCOFF_DEBUGGING_INFO 93 #ifdef XCOFF_DEBUGGING_INFO
94 #include "xcoffout.h" /* Needed for external data 94 #include "xcoffout.h" /* Needed for external data declarations. */
95 declarations for e.g. AIX 4.x. */ 95 #endif
96 #endif 96
97 97 #include "selftest.h"
98 static void general_init (const char *); 98
99 static void do_compile (void); 99 #ifdef HAVE_isl
100 #include <isl/version.h>
101 #endif
102
103 static void general_init (const char *, bool);
104 static void do_compile ();
100 static void process_options (void); 105 static void process_options (void);
101 static void backend_init (void); 106 static void backend_init (void);
102 static int lang_dependent_init (const char *); 107 static int lang_dependent_init (const char *);
103 static void init_asm_output (const char *); 108 static void init_asm_output (const char *);
104 static void finalize (bool); 109 static void finalize (bool);
122 127
123 /* Debug hooks - dependent upon command line options. */ 128 /* Debug hooks - dependent upon command line options. */
124 129
125 const struct gcc_debug_hooks *debug_hooks; 130 const struct gcc_debug_hooks *debug_hooks;
126 131
127 /* True if this is the lto front end. This is used to disable
128 gimple generation and lowering passes that are normally run on the
129 output of a front end. These passes must be bypassed for lto since
130 they have already been done before the gimple was written. */
131
132 bool in_lto_p = false;
133
134 /* The FUNCTION_DECL for the function currently being compiled, 132 /* The FUNCTION_DECL for the function currently being compiled,
135 or 0 if between functions. */ 133 or 0 if between functions. */
136 tree current_function_decl; 134 tree current_function_decl;
137 135
138 /* Set to the FUNC_BEGIN label of the current function, or NULL 136 /* Set to the FUNC_BEGIN label of the current function, or NULL
145 /* A local time stamp derived from the time of compilation. It will be 143 /* A local time stamp derived from the time of compilation. It will be
146 zero if the system cannot provide a time. It will be -1u, if the 144 zero if the system cannot provide a time. It will be -1u, if the
147 user has specified a particular random seed. */ 145 user has specified a particular random seed. */
148 unsigned local_tick; 146 unsigned local_tick;
149 147
148 /* Random number for this compilation */
149 HOST_WIDE_INT random_seed;
150
150 /* -f flags. */ 151 /* -f flags. */
151
152 /* Generate code for GNU or NeXT Objective-C runtime environment. */
153
154 #ifdef NEXT_OBJC_RUNTIME
155 int flag_next_runtime = 1;
156 #else
157 int flag_next_runtime = 0;
158 #endif
159
160 /* Nonzero means make permerror produce warnings instead of errors. */
161
162 int flag_permissive = 0;
163 152
164 /* When non-NULL, indicates that whenever space is allocated on the 153 /* When non-NULL, indicates that whenever space is allocated on the
165 stack, the resulting stack pointer must not pass this 154 stack, the resulting stack pointer must not pass this
166 address---that is, for stacks that grow downward, the stack pointer 155 address---that is, for stacks that grow downward, the stack pointer
167 must always be greater than or equal to this address; for stacks 156 must always be greater than or equal to this address; for stacks
168 that grow upward, the stack pointer must be less than this address. 157 that grow upward, the stack pointer must be less than this address.
169 At present, the rtx may be either a REG or a SYMBOL_REF, although 158 At present, the rtx may be either a REG or a SYMBOL_REF, although
170 the support provided depends on the backend. */ 159 the support provided depends on the backend. */
171 rtx stack_limit_rtx; 160 rtx stack_limit_rtx;
172 161
173 /* True if the user has tagged the function with the 'section'
174 attribute. */
175
176 bool user_defined_section_attribute = false;
177
178 struct target_flag_state default_target_flag_state; 162 struct target_flag_state default_target_flag_state;
179 #if SWITCHABLE_TARGET 163 #if SWITCHABLE_TARGET
180 struct target_flag_state *this_target_flag_state = &default_target_flag_state; 164 struct target_flag_state *this_target_flag_state = &default_target_flag_state;
181 #else 165 #else
182 #define this_target_flag_state (&default_target_flag_state) 166 #define this_target_flag_state (&default_target_flag_state)
183 #endif 167 #endif
184 168
185 typedef struct
186 {
187 const char *const string;
188 int *const variable;
189 const int on_value;
190 }
191 lang_independent_options;
192
193 /* The user symbol prefix after having resolved same. */ 169 /* The user symbol prefix after having resolved same. */
194 const char *user_label_prefix; 170 const char *user_label_prefix;
195
196 static const param_info lang_independent_params[] = {
197 #define DEFPARAM(ENUM, OPTION, HELP, DEFAULT, MIN, MAX) \
198 { OPTION, DEFAULT, MIN, MAX, HELP },
199 #include "params.def"
200 #undef DEFPARAM
201 { NULL, 0, 0, 0, NULL }
202 };
203 171
204 /* Output files for assembler code (real compiler output) 172 /* Output files for assembler code (real compiler output)
205 and debugging dumps. */ 173 and debugging dumps. */
206 174
207 FILE *asm_out_file; 175 FILE *asm_out_file;
208 FILE *aux_info_file; 176 FILE *aux_info_file;
209 FILE *stack_usage_file = NULL; 177 FILE *stack_usage_file = NULL;
210 FILE *dump_file = NULL;
211 const char *dump_file_name;
212 178
213 /* The current working directory of a translation. It's generally the 179 /* The current working directory of a translation. It's generally the
214 directory from which compilation was initiated, but a preprocessed 180 directory from which compilation was initiated, but a preprocessed
215 file may specify the original directory in which it was 181 file may specify the original directory in which it was
216 created. */ 182 created. */
279 static void 245 static void
280 init_local_tick (void) 246 init_local_tick (void)
281 { 247 {
282 if (!flag_random_seed) 248 if (!flag_random_seed)
283 { 249 {
284 /* Get some more or less random data. */
285 #ifdef HAVE_GETTIMEOFDAY 250 #ifdef HAVE_GETTIMEOFDAY
286 { 251 {
287 struct timeval tv; 252 struct timeval tv;
288 253
289 gettimeofday (&tv, NULL); 254 gettimeofday (&tv, NULL);
290 local_tick = tv.tv_sec * 1000 + tv.tv_usec / 1000; 255 local_tick = (unsigned) tv.tv_sec * 1000 + tv.tv_usec / 1000;
291 } 256 }
292 #else 257 #else
293 { 258 {
294 time_t now = time (NULL); 259 time_t now = time (NULL);
295 260
300 } 265 }
301 else 266 else
302 local_tick = -1; 267 local_tick = -1;
303 } 268 }
304 269
305 /* Set up a default flag_random_seed and local_tick, unless the user 270 /* Obtain the random_seed. Unless NOINIT, initialize it if
306 already specified one. Must be called after init_local_tick. */
307
308 static void
309 init_random_seed (void)
310 {
311 unsigned HOST_WIDE_INT value;
312 static char random_seed[HOST_BITS_PER_WIDE_INT / 4 + 3];
313
314 value = local_tick ^ getpid ();
315
316 sprintf (random_seed, HOST_WIDE_INT_PRINT_HEX, value);
317 flag_random_seed = random_seed;
318 }
319
320 /* Obtain the random_seed string. Unless NOINIT, initialize it if
321 it's not provided in the command line. */ 271 it's not provided in the command line. */
322 272
323 const char * 273 HOST_WIDE_INT
324 get_random_seed (bool noinit) 274 get_random_seed (bool noinit)
325 { 275 {
326 if (!flag_random_seed && !noinit) 276 if (!random_seed && !noinit)
327 init_random_seed (); 277 {
328 return flag_random_seed; 278 int fd = open ("/dev/urandom", O_RDONLY);
329 } 279 if (fd >= 0)
330 280 {
331 /* Modify the random_seed string to VAL. Return its previous 281 if (read (fd, &random_seed, sizeof (random_seed))
332 value. */ 282 != sizeof (random_seed))
333 283 random_seed = 0;
334 const char * 284 close (fd);
285 }
286 if (!random_seed)
287 random_seed = local_tick ^ getpid ();
288 }
289 return random_seed;
290 }
291
292 /* Set flag_random_seed to VAL, and if non-null, reinitialize random_seed. */
293
294 void
335 set_random_seed (const char *val) 295 set_random_seed (const char *val)
336 { 296 {
337 const char *old = flag_random_seed;
338 flag_random_seed = val; 297 flag_random_seed = val;
339 return old; 298 if (flag_random_seed)
299 {
300 char *endp;
301
302 /* When the driver passed in a hex number don't crc it again */
303 random_seed = strtoul (flag_random_seed, &endp, 0);
304 if (!(endp > flag_random_seed && *endp == 0))
305 random_seed = crc32_string (0, flag_random_seed);
306 }
340 } 307 }
341 308
342 /* Handler for fatal signals, such as SIGSEGV. These are transformed 309 /* Handler for fatal signals, such as SIGSEGV. These are transformed
343 into ICE messages, which is much more user friendly. In case the 310 into ICE messages, which is much more user friendly. In case the
344 error printer crashes, reset the signal to prevent infinite recursion. */ 311 error printer crashes, reset the signal to prevent infinite recursion. */
370 avoid needlessly dirtying PCH pages. */ 337 avoid needlessly dirtying PCH pages. */
371 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS) 338 if (CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_WITH_VIS)
372 && DECL_DEFER_OUTPUT (decl) != 0) 339 && DECL_DEFER_OUTPUT (decl) != 0)
373 DECL_DEFER_OUTPUT (decl) = 0; 340 DECL_DEFER_OUTPUT (decl) = 0;
374 341
375 if (TREE_CODE (decl) == VAR_DECL && DECL_SIZE (decl) == 0) 342 if (VAR_P (decl) && DECL_SIZE (decl) == 0)
376 lang_hooks.finish_incomplete_decl (decl); 343 lang_hooks.finish_incomplete_decl (decl);
377 } 344 }
378 345
379 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL 346 /* A subroutine of wrapup_global_declarations. Decide whether or not DECL
380 needs to be output. Return true if it is output. */ 347 needs to be output. Return true if it is output. */
381 348
382 bool 349 bool
383 wrapup_global_declaration_2 (tree decl) 350 wrapup_global_declaration_2 (tree decl)
384 { 351 {
385 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl)) 352 if (TREE_ASM_WRITTEN (decl) || DECL_EXTERNAL (decl)
353 || (VAR_P (decl) && DECL_HAS_VALUE_EXPR_P (decl)))
386 return false; 354 return false;
387 355
388 /* Don't write out static consts, unless we still need them. 356 /* Don't write out static consts, unless we still need them.
389 357
390 We also keep static consts if not optimizing (for debugging), 358 We also keep static consts if not optimizing (for debugging),
408 376
409 ??? A tempting alternative (for both C and C++) would be 377 ??? A tempting alternative (for both C and C++) would be
410 to force a constant to be written if and only if it is 378 to force a constant to be written if and only if it is
411 defined in a main file, as opposed to an include file. */ 379 defined in a main file, as opposed to an include file. */
412 380
413 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)) 381 if (VAR_P (decl) && TREE_STATIC (decl))
414 { 382 {
415 struct varpool_node *node; 383 varpool_node *node;
416 bool needed = true; 384 bool needed = true;
417 node = varpool_get_node (decl); 385 node = varpool_node::get (decl);
418 386
419 if (!node && flag_ltrans) 387 if (!node && flag_ltrans)
420 needed = false; 388 needed = false;
421 else if (node && node->finalized) 389 else if (node && node->definition)
422 needed = false; 390 needed = false;
423 else if (node && node->alias) 391 else if (node && node->alias)
424 needed = false; 392 needed = false;
425 else if (!cgraph_global_info_ready 393 else if (!symtab->global_info_ready
426 && (TREE_USED (decl) 394 && (TREE_USED (decl)
427 || TREE_USED (DECL_ASSEMBLER_NAME (decl)))) 395 || TREE_USED (DECL_ASSEMBLER_NAME (decl))))
428 /* needed */; 396 /* needed */;
429 else if (node && node->needed) 397 else if (node && node->analyzed)
430 /* needed */; 398 /* needed */;
431 else if (DECL_COMDAT (decl)) 399 else if (DECL_COMDAT (decl))
432 needed = false; 400 needed = false;
433 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl) 401 else if (TREE_READONLY (decl) && !TREE_PUBLIC (decl)
434 && (optimize || !flag_keep_static_consts 402 && (optimize || !flag_keep_static_consts
473 while (reconsider); 441 while (reconsider);
474 442
475 return output_something; 443 return output_something;
476 } 444 }
477 445
478 /* A subroutine of check_global_declarations. Issue appropriate warnings 446 /* Compile an entire translation unit. Write a file of assembly
479 for the global declaration DECL. */ 447 output and various debugging dumps. */
480 448
481 void 449 static void
482 check_global_declaration_1 (tree decl) 450 compile_file (void)
483 { 451 {
484 /* Warn about any function declared static but not defined. We don't 452 timevar_start (TV_PHASE_PARSING);
485 warn about variables, because many programs have static variables 453 timevar_push (TV_PARSE_GLOBAL);
486 that exist only to get some text into the object file. */ 454
487 if (TREE_CODE (decl) == FUNCTION_DECL 455 /* Parse entire file and generate initial debug information. */
488 && DECL_INITIAL (decl) == 0 456 lang_hooks.parse_file ();
489 && DECL_EXTERNAL (decl) 457
490 && ! DECL_ARTIFICIAL (decl) 458 timevar_pop (TV_PARSE_GLOBAL);
491 && ! TREE_NO_WARNING (decl) 459 timevar_stop (TV_PHASE_PARSING);
492 && ! TREE_PUBLIC (decl) 460
493 && (warn_unused_function 461 if (flag_dump_locations)
494 || TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))) 462 dump_location_info (stderr);
495 { 463
496 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) 464 /* Compilation is now finished except for writing
497 pedwarn (input_location, 0, "%q+F used but never defined", decl); 465 what's left of the symbol table output. */
498 else 466
499 warning (OPT_Wunused_function, "%q+F declared %<static%> but never defined", decl); 467 if (flag_syntax_only || flag_wpa)
500 /* This symbol is effectively an "extern" declaration now. */ 468 return;
501 TREE_PUBLIC (decl) = 1; 469
502 assemble_external (decl); 470 /* Reset maximum_field_alignment, it can be adjusted by #pragma pack
503 } 471 and this shouldn't influence any types built by the middle-end
504 472 from now on (like gcov_info_type). */
505 /* Warn about static fns or vars defined but not used. */ 473 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
506 if (((warn_unused_function && TREE_CODE (decl) == FUNCTION_DECL) 474
507 /* We don't warn about "static const" variables because the 475 ggc_protect_identifiers = false;
508 "rcs_id" idiom uses that construction. */ 476
509 || (warn_unused_variable 477 /* Run the actual compilation process. */
510 && TREE_CODE (decl) == VAR_DECL && ! TREE_READONLY (decl))) 478 if (!in_lto_p)
511 && ! DECL_IN_SYSTEM_HEADER (decl) 479 {
512 && ! TREE_USED (decl) 480 timevar_start (TV_PHASE_OPT_GEN);
513 /* The TREE_USED bit for file-scope decls is kept in the identifier, 481 symtab->finalize_compilation_unit ();
514 to handle multiple external decls in different scopes. */ 482 timevar_stop (TV_PHASE_OPT_GEN);
515 && ! (DECL_NAME (decl) && TREE_USED (DECL_NAME (decl))) 483 }
516 && ! DECL_EXTERNAL (decl) 484
517 && ! TREE_PUBLIC (decl) 485 /* Perform any post compilation-proper parser cleanups and
518 /* A volatile variable might be used in some non-obvious way. */ 486 processing. This is currently only needed for the C++ parser,
519 && ! TREE_THIS_VOLATILE (decl) 487 which can be hopefully cleaned up so this hook is no longer
520 /* Global register variables must be declared to reserve them. */ 488 necessary. */
521 && ! (TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)) 489 if (lang_hooks.decls.post_compilation_parsing_cleanups)
522 /* Otherwise, ask the language. */ 490 lang_hooks.decls.post_compilation_parsing_cleanups ();
523 && lang_hooks.decls.warn_unused_global (decl)) 491
524 warning ((TREE_CODE (decl) == FUNCTION_DECL)
525 ? OPT_Wunused_function
526 : OPT_Wunused_variable,
527 "%q+D defined but not used", decl);
528 }
529
530 /* Issue appropriate warnings for the global declarations in VEC (of
531 which there are LEN). */
532
533 void
534 check_global_declarations (tree *vec, int len)
535 {
536 int i;
537
538 for (i = 0; i < len; i++)
539 check_global_declaration_1 (vec[i]);
540 }
541
542 /* Emit debugging information for all global declarations in VEC. */
543
544 void
545 emit_debug_global_declarations (tree *vec, int len)
546 {
547 int i;
548
549 /* Avoid confusing the debug information machinery when there are errors. */
550 if (seen_error ()) 492 if (seen_error ())
551 return; 493 return;
552 494
553 timevar_push (TV_SYMOUT); 495 timevar_start (TV_PHASE_LATE_ASM);
554 for (i = 0; i < len; i++) 496
555 debug_hooks->global_decl (vec[i]); 497 /* Compilation unit is finalized. When producing non-fat LTO object, we are
556 timevar_pop (TV_SYMOUT); 498 basically finished. */
557 } 499 if (in_lto_p || !flag_lto || flag_fat_lto_objects)
558 500 {
559 /* Compile an entire translation unit. Write a file of assembly 501 /* File-scope initialization for AddressSanitizer. */
560 output and various debugging dumps. */ 502 if (flag_sanitize & SANITIZE_ADDRESS)
561 503 asan_finish_file ();
562 static void 504
563 compile_file (void) 505 if (flag_sanitize & SANITIZE_THREAD)
564 { 506 tsan_finish_file ();
565 /* Initialize yet another pass. */ 507
566 508 if (flag_check_pointer_bounds)
567 ggc_protect_identifiers = true; 509 chkp_finish_file ();
568 510
569 init_cgraph (); 511 omp_finish_file ();
570 init_final (main_input_filename); 512
571 coverage_init (aux_base_name); 513 hsa_output_brig ();
572 statistics_init (); 514
573 invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL); 515 output_shared_constant_pool ();
574 516 output_object_blocks ();
575 timevar_push (TV_PARSE); 517 finish_tm_clone_pairs ();
576 518
577 /* Call the parser, which parses the entire file (calling 519 /* Write out any pending weak symbol declarations. */
578 rest_of_compilation for each function). */ 520 weak_finish ();
579 lang_hooks.parse_file (); 521
580 522 /* This must be at the end before unwind and debug info.
581 /* Compilation is now finished except for writing 523 Some target ports emit PIC setup thunks here. */
582 what's left of the symbol table output. */ 524 targetm.asm_out.code_end ();
583 timevar_pop (TV_PARSE); 525
584 526 /* Do dbx symbols. */
585 if (flag_syntax_only || flag_wpa) 527 timevar_push (TV_SYMOUT);
586 return; 528
587 529 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
588 ggc_protect_identifiers = false; 530 if (dwarf2out_do_frame ())
589 531 dwarf2out_frame_finish ();
590 /* This must also call cgraph_finalize_compilation_unit. */ 532 #endif
591 lang_hooks.decls.final_write_globals (); 533
592 534 (*debug_hooks->finish) (main_input_filename);
593 if (seen_error ()) 535 timevar_pop (TV_SYMOUT);
594 return; 536
595 537 /* Output some stuff at end of file if nec. */
596 varpool_assemble_pending_decls (); 538
597 finish_aliases_2 (); 539 dw2_output_indirect_constants ();
598 540
599 /* Likewise for mudflap static object registrations. */ 541 /* Flush any pending external directives. */
600 if (flag_mudflap) 542 process_pending_assemble_externals ();
601 mudflap_finish_file (); 543 }
602
603 output_shared_constant_pool ();
604 output_object_blocks ();
605
606 /* Write out any pending weak symbol declarations. */
607 weak_finish ();
608
609 /* This must be at the end before unwind and debug info.
610 Some target ports emit PIC setup thunks here. */
611 targetm.asm_out.code_end ();
612
613 /* Do dbx symbols. */
614 timevar_push (TV_SYMOUT);
615
616 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO
617 if (dwarf2out_do_frame ())
618 dwarf2out_frame_finish ();
619 #endif
620
621 (*debug_hooks->finish) (main_input_filename);
622 timevar_pop (TV_SYMOUT);
623
624 /* Output some stuff at end of file if nec. */
625
626 dw2_output_indirect_constants ();
627
628 /* Flush any pending external directives. */
629 process_pending_assemble_externals ();
630 544
631 /* Emit LTO marker if LTO info has been previously emitted. This is 545 /* Emit LTO marker if LTO info has been previously emitted. This is
632 used by collect2 to determine whether an object file contains IL. 546 used by collect2 to determine whether an object file contains IL.
633 We used to emit an undefined reference here, but this produces 547 We used to emit an undefined reference here, but this produces
634 link errors if an object file with IL is stored into a shared 548 link errors if an object file with IL is stored into a shared
635 library without invoking lto1. */ 549 library without invoking lto1. */
636 if (flag_generate_lto) 550 if (flag_generate_lto || flag_generate_offload)
637 { 551 {
638 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON 552 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
639 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, 553 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE,
640 "__gnu_lto_v1", 554 "__gnu_lto_v1",
641 (unsigned HOST_WIDE_INT) 1, 8); 555 HOST_WIDE_INT_1U, 8);
642 #elif defined ASM_OUTPUT_ALIGNED_COMMON 556 #elif defined ASM_OUTPUT_ALIGNED_COMMON
643 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1", 557 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_v1",
644 (unsigned HOST_WIDE_INT) 1, 8); 558 HOST_WIDE_INT_1U, 8);
645 #else 559 #else
646 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1", 560 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_v1",
647 (unsigned HOST_WIDE_INT) 1, 561 HOST_WIDE_INT_1U,
648 (unsigned HOST_WIDE_INT) 1); 562 HOST_WIDE_INT_1U);
563 #endif
564 }
565
566 /* Let linker plugin know that this is a slim object and must be LTOed
567 even when user did not ask for it. */
568 if (flag_generate_lto && !flag_fat_lto_objects)
569 {
570 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
571 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, NULL_TREE, "__gnu_lto_slim",
572 HOST_WIDE_INT_1U, 8);
573 #elif defined ASM_OUTPUT_ALIGNED_COMMON
574 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, "__gnu_lto_slim",
575 HOST_WIDE_INT_1U, 8);
576 #else
577 ASM_OUTPUT_COMMON (asm_out_file, "__gnu_lto_slim",
578 HOST_WIDE_INT_1U,
579 HOST_WIDE_INT_1U);
649 #endif 580 #endif
650 } 581 }
651 582
652 /* Attach a special .ident directive to the end of the file to identify 583 /* Attach a special .ident directive to the end of the file to identify
653 the version of GCC which compiled this code. The format of the .ident 584 the version of GCC which compiled this code. The format of the .ident
654 string is patterned after the ones produced by native SVR4 compilers. */ 585 string is patterned after the ones produced by native SVR4 compilers. */
655 #ifdef IDENT_ASM_OP
656 if (!flag_no_ident) 586 if (!flag_no_ident)
657 { 587 {
658 const char *pkg_version = "(GNU) "; 588 const char *pkg_version = "(GNU) ";
589 char *ident_str;
659 590
660 if (strcmp ("(GCC) ", pkgversion_string)) 591 if (strcmp ("(GCC) ", pkgversion_string))
661 pkg_version = pkgversion_string; 592 pkg_version = pkgversion_string;
662 fprintf (asm_out_file, "%s\"GCC: %s%s\"\n", 593
663 IDENT_ASM_OP, pkg_version, version_string); 594 ident_str = ACONCAT (("GCC: ", pkg_version, version_string, NULL));
664 } 595 targetm.asm_out.output_ident (ident_str);
665 #endif 596 }
597
598 /* Auto profile finalization. */
599 if (flag_auto_profile)
600 end_auto_profile ();
666 601
667 /* Invoke registered plugin callbacks. */ 602 /* Invoke registered plugin callbacks. */
668 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL); 603 invoke_plugin_callbacks (PLUGIN_FINISH_UNIT, NULL);
669 604
670 /* This must be at the end. Some target ports emit end of file directives 605 /* This must be at the end. Some target ports emit end of file directives
671 into the assembly file here, and hence we can not output anything to the 606 into the assembly file here, and hence we can not output anything to the
672 assembly file after this point. */ 607 assembly file after this point. */
673 targetm.asm_out.file_end (); 608 targetm.asm_out.file_end ();
674 } 609
675 610 timevar_stop (TV_PHASE_LATE_ASM);
676 /* Indexed by enum debug_info_type. */ 611 }
677 const char *const debug_type_names[] =
678 {
679 "none", "stabs", "coff", "dwarf-2", "xcoff", "vms"
680 };
681 612
682 /* Print version information to FILE. 613 /* Print version information to FILE.
683 Each line begins with INDENT (for the case where FILE is the 614 Each line begins with INDENT (for the case where FILE is the
684 assembler output file). */ 615 assembler output file).
616
617 If SHOW_GLOBAL_STATE is true (for cc1 etc), we are within the compiler
618 proper and can print pertinent state (e.g. params and plugins).
619
620 If SHOW_GLOBAL_STATE is false (for use by libgccjit), we are outside the
621 compiler, and we don't hold the mutex on the compiler's global state:
622 we can't print params and plugins, since they might not be initialized,
623 or might be being manipulated by a compile running in another
624 thread. */
685 625
686 void 626 void
687 print_version (FILE *file, const char *indent) 627 print_version (FILE *file, const char *indent, bool show_global_state)
688 { 628 {
689 static const char fmt1[] = 629 static const char fmt1[] =
690 #ifdef __GNUC__ 630 #ifdef __GNUC__
691 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ") 631 N_("%s%s%s %sversion %s (%s)\n%s\tcompiled by GNU C version %s, ")
692 #else 632 #else
693 N_("%s%s%s %sversion %s (%s) compiled by CC, ") 633 N_("%s%s%s %sversion %s (%s) compiled by CC, ")
694 #endif 634 #endif
695 ; 635 ;
696 static const char fmt2[] = 636 static const char fmt2[] =
697 N_("GMP version %s, MPFR version %s, MPC version %s\n"); 637 N_("GMP version %s, MPFR version %s, MPC version %s, isl version %s\n");
698 static const char fmt3[] = 638 static const char fmt3[] =
699 N_("%s%swarning: %s header version %s differs from library version %s.\n"); 639 N_("%s%swarning: %s header version %s differs from library version %s.\n");
700 static const char fmt4[] = 640 static const char fmt4[] =
701 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n"); 641 N_("%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n");
702 #ifndef __VERSION__ 642 #ifndef __VERSION__
710 650
711 /* We need to stringify the GMP macro values. Ugh, gmp_version has 651 /* We need to stringify the GMP macro values. Ugh, gmp_version has
712 two string formats, "i.j.k" and "i.j" when k is zero. As of 652 two string formats, "i.j.k" and "i.j" when k is zero. As of
713 gmp-4.3.0, GMP always uses the 3 number format. */ 653 gmp-4.3.0, GMP always uses the 3 number format. */
714 #define GCC_GMP_STRINGIFY_VERSION3(X) #X 654 #define GCC_GMP_STRINGIFY_VERSION3(X) #X
715 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3(X) 655 #define GCC_GMP_STRINGIFY_VERSION2(X) GCC_GMP_STRINGIFY_VERSION3 (X)
716 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z)) 656 #define GCC_GMP_VERSION_NUM(X,Y,Z) (((X) << 16L) | ((Y) << 8) | (Z))
717 #define GCC_GMP_VERSION \ 657 #define GCC_GMP_VERSION \
718 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL) 658 GCC_GMP_VERSION_NUM(__GNU_MP_VERSION, __GNU_MP_VERSION_MINOR, __GNU_MP_VERSION_PATCHLEVEL)
719 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0 659 #if GCC_GMP_VERSION < GCC_GMP_VERSION_NUM(4,3,0) && __GNU_MP_VERSION_PATCHLEVEL == 0
720 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \ 660 #define GCC_GMP_STRINGIFY_VERSION \
721 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) 661 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
662 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR)
722 #else 663 #else
723 #define GCC_GMP_STRINGIFY_VERSION GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION) "." \ 664 #define GCC_GMP_STRINGIFY_VERSION \
724 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_MINOR) "." \ 665 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION) "." \
725 GCC_GMP_STRINGIFY_VERSION2(__GNU_MP_VERSION_PATCHLEVEL) 666 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_MINOR) "." \
667 GCC_GMP_STRINGIFY_VERSION2 (__GNU_MP_VERSION_PATCHLEVEL)
726 #endif 668 #endif
727 fprintf (file, 669 fprintf (file,
728 file == stderr ? _(fmt2) : fmt2, 670 file == stderr ? _(fmt2) : fmt2,
729 GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING); 671 GCC_GMP_STRINGIFY_VERSION, MPFR_VERSION_STRING, MPC_VERSION_STRING,
672 #ifndef HAVE_isl
673 "none"
674 #else
675 isl_version ()
676 #endif
677 );
730 if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version)) 678 if (strcmp (GCC_GMP_STRINGIFY_VERSION, gmp_version))
731 fprintf (file, 679 fprintf (file,
732 file == stderr ? _(fmt3) : fmt3, 680 file == stderr ? _(fmt3) : fmt3,
733 indent, *indent != 0 ? " " : "", 681 indent, *indent != 0 ? " " : "",
734 "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version); 682 "GMP", GCC_GMP_STRINGIFY_VERSION, gmp_version);
740 if (strcmp (MPC_VERSION_STRING, mpc_get_version ())) 688 if (strcmp (MPC_VERSION_STRING, mpc_get_version ()))
741 fprintf (file, 689 fprintf (file,
742 file == stderr ? _(fmt3) : fmt3, 690 file == stderr ? _(fmt3) : fmt3,
743 indent, *indent != 0 ? " " : "", 691 indent, *indent != 0 ? " " : "",
744 "MPC", MPC_VERSION_STRING, mpc_get_version ()); 692 "MPC", MPC_VERSION_STRING, mpc_get_version ());
745 fprintf (file, 693
746 file == stderr ? _(fmt4) : fmt4, 694 if (show_global_state)
747 indent, *indent != 0 ? " " : "", 695 {
748 PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE)); 696 fprintf (file,
749 697 file == stderr ? _(fmt4) : fmt4,
750 print_plugins_versions (file, indent); 698 indent, *indent != 0 ? " " : "",
751 } 699 PARAM_VALUE (GGC_MIN_EXPAND), PARAM_VALUE (GGC_MIN_HEAPSIZE));
752 700
753 #ifdef ASM_COMMENT_START 701 print_plugins_versions (file, indent);
702 }
703 }
704
754 static int 705 static int
755 print_to_asm_out_file (print_switch_type type, const char * text) 706 print_to_asm_out_file (print_switch_type type, const char * text)
756 { 707 {
757 bool prepend_sep = true; 708 bool prepend_sep = true;
758 709
767 return strlen (ASM_COMMENT_START); 718 return strlen (ASM_COMMENT_START);
768 719
769 case SWITCH_TYPE_DESCRIPTIVE: 720 case SWITCH_TYPE_DESCRIPTIVE:
770 if (ASM_COMMENT_START[0] == 0) 721 if (ASM_COMMENT_START[0] == 0)
771 prepend_sep = false; 722 prepend_sep = false;
772 /* Drop through. */ 723 /* FALLTHRU */
773 case SWITCH_TYPE_PASSED: 724 case SWITCH_TYPE_PASSED:
774 case SWITCH_TYPE_ENABLED: 725 case SWITCH_TYPE_ENABLED:
775 if (prepend_sep) 726 if (prepend_sep)
776 fputc (' ', asm_out_file); 727 fputc (' ', asm_out_file);
777 fputs (text, asm_out_file); 728 fputs (text, asm_out_file);
781 732
782 default: 733 default:
783 return -1; 734 return -1;
784 } 735 }
785 } 736 }
786 #endif
787 737
788 static int 738 static int
789 print_to_stderr (print_switch_type type, const char * text) 739 print_to_stderr (print_switch_type type, const char * text)
790 { 740 {
791 switch (type) 741 switch (type)
798 return 0; 748 return 0;
799 749
800 case SWITCH_TYPE_PASSED: 750 case SWITCH_TYPE_PASSED:
801 case SWITCH_TYPE_ENABLED: 751 case SWITCH_TYPE_ENABLED:
802 fputc (' ', stderr); 752 fputc (' ', stderr);
803 /* Drop through. */ 753 /* FALLTHRU */
804 754
805 case SWITCH_TYPE_DESCRIPTIVE: 755 case SWITCH_TYPE_DESCRIPTIVE:
806 fputs (text, stderr); 756 fputs (text, stderr);
807 /* No need to return the length here as 757 /* No need to return the length here as
808 print_single_switch has already done it. */ 758 print_single_switch has already done it. */
850 static void 800 static void
851 print_switch_values (print_switch_fn_type print_fn) 801 print_switch_values (print_switch_fn_type print_fn)
852 { 802 {
853 int pos = 0; 803 int pos = 0;
854 size_t j; 804 size_t j;
855
856 /* Fill in the -frandom-seed option, if the user didn't pass it, so
857 that it can be printed below. This helps reproducibility. */
858 if (!flag_random_seed)
859 init_random_seed ();
860 805
861 /* Print the options as passed. */ 806 /* Print the options as passed. */
862 pos = print_single_switch (print_fn, pos, 807 pos = print_single_switch (print_fn, pos,
863 SWITCH_TYPE_DESCRIPTIVE, _("options passed: ")); 808 SWITCH_TYPE_DESCRIPTIVE, _("options passed: "));
864 809
889 should suffice. */ 834 should suffice. */
890 pos = print_single_switch (print_fn, 0, 835 pos = print_single_switch (print_fn, 0,
891 SWITCH_TYPE_DESCRIPTIVE, _("options enabled: ")); 836 SWITCH_TYPE_DESCRIPTIVE, _("options enabled: "));
892 837
893 for (j = 0; j < cl_options_count; j++) 838 for (j = 0; j < cl_options_count; j++)
894 if ((cl_options[j].flags & CL_REPORT) 839 if (cl_options[j].cl_report
895 && option_enabled (j, &global_options) > 0) 840 && option_enabled (j, &global_options) > 0)
896 pos = print_single_switch (print_fn, pos, 841 pos = print_single_switch (print_fn, pos,
897 SWITCH_TYPE_ENABLED, cl_options[j].opt_text); 842 SWITCH_TYPE_ENABLED, cl_options[j].opt_text);
898 843
899 print_fn (SWITCH_TYPE_LINE_END, NULL); 844 print_fn (SWITCH_TYPE_LINE_END, NULL);
920 strcat (dumpname, ".s"); 865 strcat (dumpname, ".s");
921 asm_file_name = dumpname; 866 asm_file_name = dumpname;
922 } 867 }
923 if (!strcmp (asm_file_name, "-")) 868 if (!strcmp (asm_file_name, "-"))
924 asm_out_file = stdout; 869 asm_out_file = stdout;
870 else if (!canonical_filename_eq (asm_file_name, name)
871 || !strcmp (asm_file_name, HOST_BIT_BUCKET))
872 asm_out_file = fopen (asm_file_name, "w");
925 else 873 else
926 asm_out_file = fopen (asm_file_name, "w+b"); 874 /* Use UNKOWN_LOCATION to prevent gcc from printing the first
875 line in the current file. */
876 fatal_error (UNKNOWN_LOCATION,
877 "input file %qs is the same as output file",
878 asm_file_name);
927 if (asm_out_file == 0) 879 if (asm_out_file == 0)
928 fatal_error ("can%'t open %s for writing: %m", asm_file_name); 880 fatal_error (UNKNOWN_LOCATION,
881 "can%'t open %qs for writing: %m", asm_file_name);
929 } 882 }
930 883
931 if (!flag_syntax_only) 884 if (!flag_syntax_only)
932 { 885 {
933 targetm.asm_out.file_start (); 886 targetm.asm_out.file_start ();
944 /* Let the target know that the recording is over. */ 897 /* Let the target know that the recording is over. */
945 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE, 898 targetm.asm_out.record_gcc_switches (SWITCH_TYPE_DESCRIPTIVE,
946 NULL); 899 NULL);
947 } 900 }
948 else 901 else
949 inform (input_location, "-frecord-gcc-switches is not supported by the current target"); 902 inform (UNKNOWN_LOCATION,
950 } 903 "-frecord-gcc-switches is not supported by "
951 904 "the current target");
952 #ifdef ASM_COMMENT_START 905 }
906
953 if (flag_verbose_asm) 907 if (flag_verbose_asm)
954 { 908 {
955 /* Print the list of switches in effect 909 /* Print the list of switches in effect
956 into the assembler file as comments. */ 910 into the assembler file as comments. */
957 print_version (asm_out_file, ASM_COMMENT_START); 911 print_version (asm_out_file, ASM_COMMENT_START, true);
958 print_switch_values (print_to_asm_out_file); 912 print_switch_values (print_to_asm_out_file);
959 putc ('\n', asm_out_file); 913 putc ('\n', asm_out_file);
960 } 914 }
961 #endif 915 }
962 }
963 }
964
965 /* Default tree printer. Handles declarations only. */
966 bool
967 default_tree_printer (pretty_printer *pp, text_info *text, const char *spec,
968 int precision, bool wide, bool set_locus, bool hash)
969 {
970 tree t;
971
972 /* FUTURE: %+x should set the locus. */
973 if (precision != 0 || wide || hash)
974 return false;
975
976 switch (*spec)
977 {
978 case 'E':
979 t = va_arg (*text->args_ptr, tree);
980 if (TREE_CODE (t) == IDENTIFIER_NODE)
981 {
982 pp_identifier (pp, IDENTIFIER_POINTER (t));
983 return true;
984 }
985 break;
986
987 case 'D':
988 t = va_arg (*text->args_ptr, tree);
989 if (DECL_DEBUG_EXPR_IS_FROM (t) && DECL_DEBUG_EXPR (t))
990 t = DECL_DEBUG_EXPR (t);
991 break;
992
993 case 'F':
994 case 'T':
995 t = va_arg (*text->args_ptr, tree);
996 break;
997
998 case 'K':
999 percent_K_format (text);
1000 return true;
1001
1002 default:
1003 return false;
1004 }
1005
1006 if (set_locus && text->locus)
1007 *text->locus = DECL_SOURCE_LOCATION (t);
1008
1009 if (DECL_P (t))
1010 {
1011 const char *n = DECL_NAME (t)
1012 ? identifier_to_locale (lang_hooks.decl_printable_name (t, 2))
1013 : _("<anonymous>");
1014 pp_string (pp, n);
1015 }
1016 else
1017 dump_generic_node (pp, t, 0, TDF_DIAGNOSTIC, 0);
1018
1019 return true;
1020 } 916 }
1021 917
1022 /* A helper function; used as the reallocator function for cpp's line 918 /* A helper function; used as the reallocator function for cpp's line
1023 table. */ 919 table. */
1024 static void * 920 static void *
1025 realloc_for_line_map (void *ptr, size_t len) 921 realloc_for_line_map (void *ptr, size_t len)
1026 { 922 {
1027 return GGC_RESIZEVAR (void, ptr, len); 923 return ggc_realloc (ptr, len);
1028 } 924 }
1029 925
1030 /* A helper function: used as the allocator function for 926 /* A helper function: used as the allocator function for
1031 identifier_to_locale. */ 927 identifier_to_locale. */
1032 static void * 928 static void *
1046 "dynamic", 942 "dynamic",
1047 "dynamic,bounded" 943 "dynamic,bounded"
1048 }; 944 };
1049 HOST_WIDE_INT stack_usage = current_function_static_stack_size; 945 HOST_WIDE_INT stack_usage = current_function_static_stack_size;
1050 enum stack_usage_kind_type stack_usage_kind; 946 enum stack_usage_kind_type stack_usage_kind;
1051 expanded_location loc;
1052 const char *raw_id, *id;
1053 947
1054 if (stack_usage < 0) 948 if (stack_usage < 0)
1055 { 949 {
1056 if (!warning_issued) 950 if (!warning_issued)
1057 { 951 {
1058 warning (0, "-fstack-usage not supported for this target"); 952 warning (0, "stack usage computation not supported for this target");
1059 warning_issued = true; 953 warning_issued = true;
1060 } 954 }
1061 return; 955 return;
1062 } 956 }
1063 957
1080 974
1081 /* Add the size even in the unbounded case, this can't hurt. */ 975 /* Add the size even in the unbounded case, this can't hurt. */
1082 stack_usage += current_function_dynamic_stack_size; 976 stack_usage += current_function_dynamic_stack_size;
1083 } 977 }
1084 978
1085 loc = expand_location (DECL_SOURCE_LOCATION (current_function_decl)); 979 if (flag_stack_usage)
1086 980 {
1087 /* Strip the scope prefix if any. */ 981 expanded_location loc
1088 raw_id = lang_hooks.decl_printable_name (current_function_decl, 2); 982 = expand_location (DECL_SOURCE_LOCATION (current_function_decl));
1089 id = strrchr (raw_id, '.'); 983 /* We don't want to print the full qualified name because it can be long,
1090 if (id) 984 so we strip the scope prefix, but we may need to deal with the suffix
1091 id++; 985 created by the compiler. */
1092 else 986 const char *suffix
1093 id = raw_id; 987 = strchr (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), '.');
1094 988 const char *name
1095 fprintf (stack_usage_file, 989 = lang_hooks.decl_printable_name (current_function_decl, 2);
1096 "%s:%d:%d:%s\t"HOST_WIDE_INT_PRINT_DEC"\t%s\n", 990 if (suffix)
1097 lbasename (loc.file), 991 {
1098 loc.line, 992 const char *dot = strchr (name, '.');
1099 loc.column, 993 while (dot && strcasecmp (dot, suffix) != 0)
1100 id, 994 {
1101 stack_usage, 995 name = dot + 1;
1102 stack_usage_kind_str[stack_usage_kind]); 996 dot = strchr (name, '.');
997 }
998 }
999 else
1000 {
1001 const char *dot = strrchr (name, '.');
1002 if (dot)
1003 name = dot + 1;
1004 }
1005
1006 fprintf (stack_usage_file,
1007 "%s:%d:%d:%s\t" HOST_WIDE_INT_PRINT_DEC"\t%s\n",
1008 lbasename (loc.file),
1009 loc.line,
1010 loc.column,
1011 name,
1012 stack_usage,
1013 stack_usage_kind_str[stack_usage_kind]);
1014 }
1015
1016 if (warn_stack_usage >= 0)
1017 {
1018 const location_t loc = DECL_SOURCE_LOCATION (current_function_decl);
1019
1020 if (stack_usage_kind == DYNAMIC)
1021 warning_at (loc, OPT_Wstack_usage_, "stack usage might be unbounded");
1022 else if (stack_usage > warn_stack_usage)
1023 {
1024 if (stack_usage_kind == DYNAMIC_BOUNDED)
1025 warning_at (loc,
1026 OPT_Wstack_usage_, "stack usage might be %wd bytes",
1027 stack_usage);
1028 else
1029 warning_at (loc, OPT_Wstack_usage_, "stack usage is %wd bytes",
1030 stack_usage);
1031 }
1032 }
1103 } 1033 }
1104 1034
1105 /* Open an auxiliary output file. */ 1035 /* Open an auxiliary output file. */
1106 static FILE * 1036 static FILE *
1107 open_auxiliary_file (const char *ext) 1037 open_auxiliary_file (const char *ext)
1110 FILE *file; 1040 FILE *file;
1111 1041
1112 filename = concat (aux_base_name, ".", ext, NULL); 1042 filename = concat (aux_base_name, ".", ext, NULL);
1113 file = fopen (filename, "w"); 1043 file = fopen (filename, "w");
1114 if (!file) 1044 if (!file)
1115 fatal_error ("can%'t open %s for writing: %m", filename); 1045 fatal_error (input_location, "can%'t open %s for writing: %m", filename);
1116 free (filename); 1046 free (filename);
1117 return file; 1047 return file;
1048 }
1049
1050 /* Alternative diagnostics callback for reentered ICE reporting. */
1051
1052 static void
1053 internal_error_reentered (diagnostic_context *, const char *, va_list *)
1054 {
1055 /* Flush the dump file if emergency_dump_function itself caused an ICE. */
1056 if (dump_file)
1057 fflush (dump_file);
1058 }
1059
1060 /* Auxiliary callback for the diagnostics code. */
1061
1062 static void
1063 internal_error_function (diagnostic_context *, const char *, va_list *)
1064 {
1065 global_dc->internal_error = internal_error_reentered;
1066 warn_if_plugins ();
1067 emergency_dump_function ();
1118 } 1068 }
1119 1069
1120 /* Initialization of the front end environment, before command line 1070 /* Initialization of the front end environment, before command line
1121 options are parsed. Signal handlers, internationalization etc. 1071 options are parsed. Signal handlers, internationalization etc.
1122 ARGV0 is main's argv[0]. */ 1072 ARGV0 is main's argv[0]. */
1123 static void 1073 static void
1124 general_init (const char *argv0) 1074 general_init (const char *argv0, bool init_signals)
1125 { 1075 {
1126 const char *p; 1076 const char *p;
1127 1077
1128 p = argv0 + strlen (argv0); 1078 p = argv0 + strlen (argv0);
1129 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1])) 1079 while (p != argv0 && !IS_DIR_SEPARATOR (p[-1]))
1143 identifier_to_locale_free = ggc_free; 1093 identifier_to_locale_free = ggc_free;
1144 1094
1145 /* Initialize the diagnostics reporting machinery, so option parsing 1095 /* Initialize the diagnostics reporting machinery, so option parsing
1146 can give warnings and errors. */ 1096 can give warnings and errors. */
1147 diagnostic_initialize (global_dc, N_OPTS); 1097 diagnostic_initialize (global_dc, N_OPTS);
1148 diagnostic_starter (global_dc) = default_tree_diagnostic_starter;
1149 /* Set a default printer. Language specific initializations will 1098 /* Set a default printer. Language specific initializations will
1150 override it later. */ 1099 override it later. */
1151 pp_format_decoder (global_dc->printer) = &default_tree_printer; 1100 tree_diagnostics_defaults (global_dc);
1101
1102 global_dc->show_caret
1103 = global_options_init.x_flag_diagnostics_show_caret;
1152 global_dc->show_option_requested 1104 global_dc->show_option_requested
1153 = global_options_init.x_flag_diagnostics_show_option; 1105 = global_options_init.x_flag_diagnostics_show_option;
1154 global_dc->show_column 1106 global_dc->show_column
1155 = global_options_init.x_flag_show_column; 1107 = global_options_init.x_flag_show_column;
1156 global_dc->internal_error = plugins_internal_error_function; 1108 global_dc->internal_error = internal_error_function;
1157 global_dc->option_enabled = option_enabled; 1109 global_dc->option_enabled = option_enabled;
1158 global_dc->option_state = &global_options; 1110 global_dc->option_state = &global_options;
1159 global_dc->option_name = option_name; 1111 global_dc->option_name = option_name;
1160 1112
1161 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */ 1113 if (init_signals)
1114 {
1115 /* Trap fatal signals, e.g. SIGSEGV, and convert them to ICE messages. */
1162 #ifdef SIGSEGV 1116 #ifdef SIGSEGV
1163 signal (SIGSEGV, crash_signal); 1117 signal (SIGSEGV, crash_signal);
1164 #endif 1118 #endif
1165 #ifdef SIGILL 1119 #ifdef SIGILL
1166 signal (SIGILL, crash_signal); 1120 signal (SIGILL, crash_signal);
1167 #endif 1121 #endif
1168 #ifdef SIGBUS 1122 #ifdef SIGBUS
1169 signal (SIGBUS, crash_signal); 1123 signal (SIGBUS, crash_signal);
1170 #endif 1124 #endif
1171 #ifdef SIGABRT 1125 #ifdef SIGABRT
1172 signal (SIGABRT, crash_signal); 1126 signal (SIGABRT, crash_signal);
1173 #endif 1127 #endif
1174 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT) 1128 #if defined SIGIOT && (!defined SIGABRT || SIGABRT != SIGIOT)
1175 signal (SIGIOT, crash_signal); 1129 signal (SIGIOT, crash_signal);
1176 #endif 1130 #endif
1177 #ifdef SIGFPE 1131 #ifdef SIGFPE
1178 signal (SIGFPE, crash_signal); 1132 signal (SIGFPE, crash_signal);
1179 #endif 1133 #endif
1180 1134
1181 /* Other host-specific signal setup. */ 1135 /* Other host-specific signal setup. */
1182 (*host_hooks.extra_signals)(); 1136 (*host_hooks.extra_signals)();
1137 }
1183 1138
1184 /* Initialize the garbage-collector, string pools and tree type hash 1139 /* Initialize the garbage-collector, string pools and tree type hash
1185 table. */ 1140 table. */
1186 init_ggc (); 1141 init_ggc ();
1187 init_stringpool (); 1142 init_stringpool ();
1188 line_table = ggc_alloc_line_maps (); 1143 input_location = UNKNOWN_LOCATION;
1189 linemap_init (line_table); 1144 line_table = ggc_alloc<line_maps> ();
1145 linemap_init (line_table, BUILTINS_LOCATION);
1190 line_table->reallocator = realloc_for_line_map; 1146 line_table->reallocator = realloc_for_line_map;
1147 line_table->round_alloc_size = ggc_round_alloc_size;
1148 line_table->default_range_bits = 5;
1191 init_ttree (); 1149 init_ttree ();
1192 1150
1193 /* Initialize register usage now so switches may override. */ 1151 /* Initialize register usage now so switches may override. */
1194 init_reg_sets (); 1152 init_reg_sets ();
1195 1153
1196 /* Register the language-independent parameters. */ 1154 /* Register the language-independent parameters. */
1197 add_params (lang_independent_params, LAST_PARAM); 1155 global_init_params ();
1198 targetm.target_option.default_params (); 1156
1199 1157 /* This must be done after global_init_params but before argument
1200 /* This must be done after add_params but before argument processing. */ 1158 processing. */
1201 init_ggc_heuristics(); 1159 init_ggc_heuristics ();
1202 init_optimization_passes (); 1160
1161 /* Create the singleton holder for global state. This creates the
1162 dump manager. */
1163 g = new gcc::context ();
1164
1165 /* Allow languages and middle-end to register their dumps before the
1166 optimization passes. */
1167 g->get_dumps ()->register_dumps ();
1168
1169 /* Create the passes. */
1170 g->set_passes (new gcc::pass_manager (g));
1171
1172 symtab = new (ggc_cleared_alloc <symbol_table> ()) symbol_table ();
1173
1203 statistics_early_init (); 1174 statistics_early_init ();
1204 finish_params (); 1175 finish_params ();
1205 } 1176 }
1206 1177
1207 /* Return true if the current target supports -fsection-anchors. */ 1178 /* Return true if the current target supports -fsection-anchors. */
1251 This can happen with incorrect pre-processed input. */ 1222 This can happen with incorrect pre-processed input. */
1252 debug_hooks = &do_nothing_debug_hooks; 1223 debug_hooks = &do_nothing_debug_hooks;
1253 1224
1254 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT; 1225 maximum_field_alignment = initial_max_fld_align * BITS_PER_UNIT;
1255 1226
1256 /* This replaces set_Wunused. */
1257 if (warn_unused_function == -1)
1258 warn_unused_function = warn_unused;
1259 if (warn_unused_label == -1)
1260 warn_unused_label = warn_unused;
1261 /* Wunused-parameter is enabled if both -Wunused -Wextra are enabled. */
1262 if (warn_unused_parameter == -1)
1263 warn_unused_parameter = (warn_unused && extra_warnings);
1264 if (warn_unused_variable == -1)
1265 warn_unused_variable = warn_unused;
1266 /* Wunused-but-set-parameter is enabled if both -Wunused -Wextra are
1267 enabled. */
1268 if (warn_unused_but_set_parameter == -1)
1269 warn_unused_but_set_parameter = (warn_unused && extra_warnings);
1270 if (warn_unused_but_set_variable == -1)
1271 warn_unused_but_set_variable = warn_unused;
1272 if (warn_unused_value == -1)
1273 warn_unused_value = warn_unused;
1274
1275 /* This replaces set_Wextra. */
1276 if (warn_uninitialized == -1)
1277 warn_uninitialized = extra_warnings;
1278
1279 /* Allow the front end to perform consistency checks and do further 1227 /* Allow the front end to perform consistency checks and do further
1280 initialization based on the command line options. This hook also 1228 initialization based on the command line options. This hook also
1281 sets the original filename if appropriate (e.g. foo.i -> foo.c) 1229 sets the original filename if appropriate (e.g. foo.i -> foo.c)
1282 so we can correctly initialize debug output. */ 1230 so we can correctly initialize debug output. */
1283 no_backend = lang_hooks.post_options (&main_input_filename); 1231 no_backend = lang_hooks.post_options (&main_input_filename);
1284 1232
1285 /* Some machines may reject certain combinations of options. */ 1233 /* Some machines may reject certain combinations of options. */
1234 location_t saved_location = input_location;
1235 input_location = UNKNOWN_LOCATION;
1286 targetm.target_option.override (); 1236 targetm.target_option.override ();
1237 input_location = saved_location;
1238
1239 if (flag_diagnostics_generate_patch)
1240 global_dc->edit_context_ptr = new edit_context ();
1287 1241
1288 /* Avoid any informative notes in the second run of -fcompare-debug. */ 1242 /* Avoid any informative notes in the second run of -fcompare-debug. */
1289 if (flag_compare_debug) 1243 if (flag_compare_debug)
1290 diagnostic_inhibit_notes (global_dc); 1244 diagnostic_inhibit_notes (global_dc);
1291 1245
1292 if (flag_section_anchors && !target_supports_section_anchors_p ()) 1246 if (flag_section_anchors && !target_supports_section_anchors_p ())
1293 { 1247 {
1294 warning (OPT_fsection_anchors, 1248 warning_at (UNKNOWN_LOCATION, OPT_fsection_anchors,
1295 "this target does not support %qs", "-fsection-anchors"); 1249 "this target does not support %qs",
1250 "-fsection-anchors");
1296 flag_section_anchors = 0; 1251 flag_section_anchors = 0;
1297 } 1252 }
1298 1253
1299 if (flag_short_enums == 2) 1254 if (flag_short_enums == 2)
1300 flag_short_enums = targetm.default_short_enums (); 1255 flag_short_enums = targetm.default_short_enums ();
1310 aux_base_name = name; 1265 aux_base_name = name;
1311 } 1266 }
1312 else 1267 else
1313 aux_base_name = "gccaux"; 1268 aux_base_name = "gccaux";
1314 1269
1315 #ifndef HAVE_cloog 1270 #ifndef HAVE_isl
1316 if (flag_graphite 1271 if (flag_graphite
1272 || flag_loop_nest_optimize
1317 || flag_graphite_identity 1273 || flag_graphite_identity
1318 || flag_loop_block
1319 || flag_loop_flatten
1320 || flag_loop_interchange
1321 || flag_loop_strip_mine
1322 || flag_loop_parallelize_all) 1274 || flag_loop_parallelize_all)
1323 sorry ("Graphite loop optimizations cannot be used (-fgraphite, " 1275 sorry ("Graphite loop optimizations cannot be used (isl is not available) "
1324 "-fgraphite-identity, -floop-block, -floop-flatten, " 1276 "(-fgraphite, -fgraphite-identity, -floop-nest-optimize, "
1325 "-floop-interchange, -floop-strip-mine, -floop-parallelize-all, " 1277 "-floop-parallelize-all)");
1326 "and -ftree-loop-linear)"); 1278 #endif
1327 #endif 1279
1280 if (flag_cf_protection != CF_NONE
1281 && !(flag_cf_protection & CF_SET))
1282 {
1283 if (flag_cf_protection == CF_FULL)
1284 {
1285 error_at (UNKNOWN_LOCATION,
1286 "%<-fcf-protection=full%> is not supported for this "
1287 "target");
1288 flag_cf_protection = CF_NONE;
1289 }
1290 if (flag_cf_protection == CF_BRANCH)
1291 {
1292 error_at (UNKNOWN_LOCATION,
1293 "%<-fcf-protection=branch%> is not supported for this "
1294 "target");
1295 flag_cf_protection = CF_NONE;
1296 }
1297 if (flag_cf_protection == CF_RETURN)
1298 {
1299 error_at (UNKNOWN_LOCATION,
1300 "%<-fcf-protection=return%> is not supported for this "
1301 "target");
1302 flag_cf_protection = CF_NONE;
1303 }
1304 }
1305
1306 if (flag_check_pointer_bounds)
1307 {
1308 if (targetm.chkp_bound_mode () == VOIDmode)
1309 {
1310 error_at (UNKNOWN_LOCATION,
1311 "%<-fcheck-pointer-bounds%> is not supported for this "
1312 "target");
1313 flag_check_pointer_bounds = 0;
1314 }
1315
1316 if (flag_sanitize & SANITIZE_BOUNDS_STRICT)
1317 {
1318 error_at (UNKNOWN_LOCATION,
1319 "%<-fcheck-pointer-bounds%> is not supported with "
1320 "%<-fsanitize=bounds-strict%>");
1321 flag_check_pointer_bounds = 0;
1322 }
1323 else if (flag_sanitize & SANITIZE_BOUNDS)
1324 {
1325 error_at (UNKNOWN_LOCATION,
1326 "%<-fcheck-pointer-bounds%> is not supported with "
1327 "%<-fsanitize=bounds%>");
1328 flag_check_pointer_bounds = 0;
1329 }
1330
1331 if (flag_sanitize & SANITIZE_ADDRESS)
1332 {
1333 error_at (UNKNOWN_LOCATION,
1334 "%<-fcheck-pointer-bounds%> is not supported with "
1335 "Address Sanitizer");
1336 flag_check_pointer_bounds = 0;
1337 }
1338
1339 if (flag_sanitize & SANITIZE_THREAD)
1340 {
1341 error_at (UNKNOWN_LOCATION,
1342 "%<-fcheck-pointer-bounds%> is not supported with "
1343 "Thread Sanitizer");
1344
1345 flag_check_pointer_bounds = 0;
1346 }
1347 }
1348
1349 /* One region RA really helps to decrease the code size. */
1350 if (flag_ira_region == IRA_REGION_AUTODETECT)
1351 flag_ira_region
1352 = optimize_size || !optimize ? IRA_REGION_ONE : IRA_REGION_MIXED;
1353
1354 if (!abi_version_at_least (2))
1355 {
1356 /* -fabi-version=1 support was removed after GCC 4.9. */
1357 error_at (UNKNOWN_LOCATION,
1358 "%<-fabi-version=1%> is no longer supported");
1359 flag_abi_version = 2;
1360 }
1328 1361
1329 /* Unrolling all loops implies that standard loop unrolling must also 1362 /* Unrolling all loops implies that standard loop unrolling must also
1330 be done. */ 1363 be done. */
1331 if (flag_unroll_all_loops) 1364 if (flag_unroll_all_loops)
1332 flag_unroll_loops = 1; 1365 flag_unroll_loops = 1;
1333 1366
1334 /* web and rename-registers help when run after loop unrolling. */ 1367 /* web and rename-registers help when run after loop unrolling. */
1335 if (flag_web == AUTODETECT_VALUE) 1368 if (flag_web == AUTODETECT_VALUE)
1336 flag_web = flag_unroll_loops || flag_peel_loops; 1369 flag_web = flag_unroll_loops;
1337 1370
1338 if (flag_rename_registers == AUTODETECT_VALUE) 1371 if (flag_rename_registers == AUTODETECT_VALUE)
1339 flag_rename_registers = flag_unroll_loops || flag_peel_loops; 1372 flag_rename_registers = flag_unroll_loops;
1340 1373
1341 if (flag_non_call_exceptions) 1374 if (flag_non_call_exceptions)
1342 flag_asynchronous_unwind_tables = 1; 1375 flag_asynchronous_unwind_tables = 1;
1343 if (flag_asynchronous_unwind_tables) 1376 if (flag_asynchronous_unwind_tables)
1344 flag_unwind_tables = 1; 1377 flag_unwind_tables = 1;
1347 flag_profile_values = 1; 1380 flag_profile_values = 1;
1348 1381
1349 /* Warn about options that are not supported on this machine. */ 1382 /* Warn about options that are not supported on this machine. */
1350 #ifndef INSN_SCHEDULING 1383 #ifndef INSN_SCHEDULING
1351 if (flag_schedule_insns || flag_schedule_insns_after_reload) 1384 if (flag_schedule_insns || flag_schedule_insns_after_reload)
1352 warning (0, "instruction scheduling not supported on this target machine"); 1385 warning_at (UNKNOWN_LOCATION, 0,
1353 #endif 1386 "instruction scheduling not supported on this target machine");
1354 #ifndef DELAY_SLOTS 1387 #endif
1355 if (flag_delayed_branch) 1388 if (!DELAY_SLOTS && flag_delayed_branch)
1356 warning (0, "this target machine does not have delayed branches"); 1389 warning_at (UNKNOWN_LOCATION, 0,
1357 #endif 1390 "this target machine does not have delayed branches");
1358 1391
1359 user_label_prefix = USER_LABEL_PREFIX; 1392 user_label_prefix = USER_LABEL_PREFIX;
1360 if (flag_leading_underscore != -1) 1393 if (flag_leading_underscore != -1)
1361 { 1394 {
1362 /* If the default prefix is more complicated than "" or "_", 1395 /* If the default prefix is more complicated than "" or "_",
1365 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0)) 1398 (user_label_prefix[0] == '_' && user_label_prefix[1] == 0))
1366 { 1399 {
1367 user_label_prefix = flag_leading_underscore ? "_" : ""; 1400 user_label_prefix = flag_leading_underscore ? "_" : "";
1368 } 1401 }
1369 else 1402 else
1370 warning (0, "-f%sleading-underscore not supported on this target machine", 1403 warning_at (UNKNOWN_LOCATION, 0,
1371 flag_leading_underscore ? "" : "no-"); 1404 "-f%sleading-underscore not supported on this "
1405 "target machine", flag_leading_underscore ? "" : "no-");
1372 } 1406 }
1373 1407
1374 /* If we are in verbose mode, write out the version and maybe all the 1408 /* If we are in verbose mode, write out the version and maybe all the
1375 option flags in use. */ 1409 option flags in use. */
1376 if (version_flag) 1410 if (version_flag)
1377 { 1411 {
1378 print_version (stderr, ""); 1412 print_version (stderr, "", true);
1379 if (! quiet_flag) 1413 if (! quiet_flag)
1380 print_switch_values (print_to_stderr); 1414 print_switch_values (print_to_stderr);
1381 } 1415 }
1382 1416
1383 if (flag_syntax_only) 1417 if (flag_syntax_only)
1402 if (flag_dump_final_insns && !flag_syntax_only && !no_backend) 1436 if (flag_dump_final_insns && !flag_syntax_only && !no_backend)
1403 { 1437 {
1404 FILE *final_output = fopen (flag_dump_final_insns, "w"); 1438 FILE *final_output = fopen (flag_dump_final_insns, "w");
1405 if (!final_output) 1439 if (!final_output)
1406 { 1440 {
1407 error ("could not open final insn dump file %qs: %m", 1441 error_at (UNKNOWN_LOCATION,
1408 flag_dump_final_insns); 1442 "could not open final insn dump file %qs: %m",
1443 flag_dump_final_insns);
1409 flag_dump_final_insns = NULL; 1444 flag_dump_final_insns = NULL;
1410 } 1445 }
1411 else if (fclose (final_output)) 1446 else if (fclose (final_output))
1412 { 1447 {
1413 error ("could not close zeroed insn dump file %qs: %m", 1448 error_at (UNKNOWN_LOCATION,
1414 flag_dump_final_insns); 1449 "could not close zeroed insn dump file %qs: %m",
1450 flag_dump_final_insns);
1415 flag_dump_final_insns = NULL; 1451 flag_dump_final_insns = NULL;
1416 } 1452 }
1417 } 1453 }
1418
1419 /* Unless over-ridden for the target, assume that all DWARF levels
1420 may be emitted, if DWARF2_DEBUG is selected. */
1421 if (dwarf_strict < 0)
1422 dwarf_strict = 0;
1423 1454
1424 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging 1455 /* A lot of code assumes write_symbols == NO_DEBUG if the debugging
1425 level is 0. */ 1456 level is 0. */
1426 if (debug_info_level == DINFO_LEVEL_NONE) 1457 if (debug_info_level == DINFO_LEVEL_NONE)
1427 write_symbols = NO_DEBUG; 1458 write_symbols = NO_DEBUG;
1434 #endif 1465 #endif
1435 #if defined(XCOFF_DEBUGGING_INFO) 1466 #if defined(XCOFF_DEBUGGING_INFO)
1436 else if (write_symbols == XCOFF_DEBUG) 1467 else if (write_symbols == XCOFF_DEBUG)
1437 debug_hooks = &xcoff_debug_hooks; 1468 debug_hooks = &xcoff_debug_hooks;
1438 #endif 1469 #endif
1439 #ifdef SDB_DEBUGGING_INFO 1470 else if (SDB_DEBUGGING_INFO && write_symbols == SDB_DEBUG)
1440 else if (write_symbols == SDB_DEBUG)
1441 debug_hooks = &sdb_debug_hooks; 1471 debug_hooks = &sdb_debug_hooks;
1442 #endif
1443 #ifdef DWARF2_DEBUGGING_INFO 1472 #ifdef DWARF2_DEBUGGING_INFO
1444 else if (write_symbols == DWARF2_DEBUG) 1473 else if (write_symbols == DWARF2_DEBUG)
1445 debug_hooks = &dwarf2_debug_hooks; 1474 debug_hooks = &dwarf2_debug_hooks;
1446 #endif 1475 #endif
1447 #ifdef VMS_DEBUGGING_INFO 1476 #ifdef VMS_DEBUGGING_INFO
1448 else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG) 1477 else if (write_symbols == VMS_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
1449 debug_hooks = &vmsdbg_debug_hooks; 1478 debug_hooks = &vmsdbg_debug_hooks;
1450 #endif 1479 #endif
1480 #ifdef DWARF2_LINENO_DEBUGGING_INFO
1481 else if (write_symbols == DWARF2_DEBUG)
1482 debug_hooks = &dwarf2_lineno_debug_hooks;
1483 #endif
1451 else 1484 else
1452 error ("target system does not support the \"%s\" debug format", 1485 error_at (UNKNOWN_LOCATION,
1453 debug_type_names[write_symbols]); 1486 "target system does not support the %qs debug format",
1487 debug_type_names[write_symbols]);
1454 1488
1455 /* We know which debug output will be used so we can set flag_var_tracking 1489 /* We know which debug output will be used so we can set flag_var_tracking
1456 and flag_var_tracking_uninit if the user has not specified them. */ 1490 and flag_var_tracking_uninit if the user has not specified them. */
1457 if (debug_info_level < DINFO_LEVEL_NORMAL 1491 if (debug_info_level < DINFO_LEVEL_NORMAL
1458 || debug_hooks->var_location == do_nothing_debug_hooks.var_location) 1492 || debug_hooks->var_location == do_nothing_debug_hooks.var_location)
1459 { 1493 {
1460 if (flag_var_tracking == 1 1494 if (flag_var_tracking == 1
1461 || flag_var_tracking_uninit == 1) 1495 || flag_var_tracking_uninit == 1)
1462 { 1496 {
1463 if (debug_info_level < DINFO_LEVEL_NORMAL) 1497 if (debug_info_level < DINFO_LEVEL_NORMAL)
1464 warning (0, "variable tracking requested, but useless unless " 1498 warning_at (UNKNOWN_LOCATION, 0,
1465 "producing debug info"); 1499 "variable tracking requested, but useless unless "
1500 "producing debug info");
1466 else 1501 else
1467 warning (0, "variable tracking requested, but not supported " 1502 warning_at (UNKNOWN_LOCATION, 0,
1468 "by this debug format"); 1503 "variable tracking requested, but not supported "
1504 "by this debug format");
1469 } 1505 }
1470 flag_var_tracking = 0; 1506 flag_var_tracking = 0;
1471 flag_var_tracking_uninit = 0; 1507 flag_var_tracking_uninit = 0;
1472 } 1508 }
1473 1509
1478 debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks); 1514 debug_hooks = dump_go_spec_init (flag_dump_go_spec, debug_hooks);
1479 1515
1480 /* If the user specifically requested variable tracking with tagging 1516 /* If the user specifically requested variable tracking with tagging
1481 uninitialized variables, we need to turn on variable tracking. 1517 uninitialized variables, we need to turn on variable tracking.
1482 (We already determined above that variable tracking is feasible.) */ 1518 (We already determined above that variable tracking is feasible.) */
1483 if (flag_var_tracking_uninit) 1519 if (flag_var_tracking_uninit == 1)
1484 flag_var_tracking = 1; 1520 flag_var_tracking = 1;
1485 1521
1486 if (flag_var_tracking == AUTODETECT_VALUE) 1522 if (flag_var_tracking == AUTODETECT_VALUE)
1487 flag_var_tracking = optimize >= 1; 1523 flag_var_tracking = optimize >= 1;
1524
1525 if (flag_var_tracking_uninit == AUTODETECT_VALUE)
1526 flag_var_tracking_uninit = flag_var_tracking;
1488 1527
1489 if (flag_var_tracking_assignments == AUTODETECT_VALUE) 1528 if (flag_var_tracking_assignments == AUTODETECT_VALUE)
1490 flag_var_tracking_assignments = flag_var_tracking 1529 flag_var_tracking_assignments = flag_var_tracking
1491 && !(flag_selective_scheduling || flag_selective_scheduling2); 1530 && !(flag_selective_scheduling || flag_selective_scheduling2);
1492 1531
1496 if (flag_var_tracking_assignments && !flag_var_tracking) 1535 if (flag_var_tracking_assignments && !flag_var_tracking)
1497 flag_var_tracking = flag_var_tracking_assignments = -1; 1536 flag_var_tracking = flag_var_tracking_assignments = -1;
1498 1537
1499 if (flag_var_tracking_assignments 1538 if (flag_var_tracking_assignments
1500 && (flag_selective_scheduling || flag_selective_scheduling2)) 1539 && (flag_selective_scheduling || flag_selective_scheduling2))
1501 warning (0, "var-tracking-assignments changes selective scheduling"); 1540 warning_at (UNKNOWN_LOCATION, 0,
1541 "var-tracking-assignments changes selective scheduling");
1502 1542
1503 if (flag_tree_cselim == AUTODETECT_VALUE) 1543 if (flag_tree_cselim == AUTODETECT_VALUE)
1504 #ifdef HAVE_conditional_move 1544 {
1505 flag_tree_cselim = 1; 1545 if (HAVE_conditional_move)
1506 #else 1546 flag_tree_cselim = 1;
1507 flag_tree_cselim = 0; 1547 else
1508 #endif 1548 flag_tree_cselim = 0;
1549 }
1509 1550
1510 /* If auxiliary info generation is desired, open the output file. 1551 /* If auxiliary info generation is desired, open the output file.
1511 This goes in the same directory as the source file--unlike 1552 This goes in the same directory as the source file--unlike
1512 all the other output files. */ 1553 all the other output files. */
1513 if (flag_gen_aux_info) 1554 if (flag_gen_aux_info)
1514 { 1555 {
1515 aux_info_file = fopen (aux_info_file_name, "w"); 1556 aux_info_file = fopen (aux_info_file_name, "w");
1516 if (aux_info_file == 0) 1557 if (aux_info_file == 0)
1517 fatal_error ("can%'t open %s: %m", aux_info_file_name); 1558 fatal_error (UNKNOWN_LOCATION,
1518 } 1559 "can%'t open %s: %m", aux_info_file_name);
1519 1560 }
1520 if (! targetm.have_named_sections) 1561
1562 if (!targetm_common.have_named_sections)
1521 { 1563 {
1522 if (flag_function_sections) 1564 if (flag_function_sections)
1523 { 1565 {
1524 warning (0, "-ffunction-sections not supported for this target"); 1566 warning_at (UNKNOWN_LOCATION, 0,
1567 "-ffunction-sections not supported for this target");
1525 flag_function_sections = 0; 1568 flag_function_sections = 0;
1526 } 1569 }
1527 if (flag_data_sections) 1570 if (flag_data_sections)
1528 { 1571 {
1529 warning (0, "-fdata-sections not supported for this target"); 1572 warning_at (UNKNOWN_LOCATION, 0,
1573 "-fdata-sections not supported for this target");
1530 flag_data_sections = 0; 1574 flag_data_sections = 0;
1531 } 1575 }
1532 } 1576 }
1533 1577
1534 if (flag_function_sections && profile_flag) 1578 if (flag_prefetch_loop_arrays > 0 && !targetm.code_for_prefetch)
1535 { 1579 {
1536 warning (0, "-ffunction-sections disabled; it makes profiling impossible"); 1580 warning_at (UNKNOWN_LOCATION, 0,
1537 flag_function_sections = 0; 1581 "-fprefetch-loop-arrays not supported for this target");
1538 }
1539
1540 #ifndef HAVE_prefetch
1541 if (flag_prefetch_loop_arrays > 0)
1542 {
1543 warning (0, "-fprefetch-loop-arrays not supported for this target");
1544 flag_prefetch_loop_arrays = 0; 1582 flag_prefetch_loop_arrays = 0;
1545 } 1583 }
1546 #else 1584 else if (flag_prefetch_loop_arrays > 0 && !targetm.have_prefetch ())
1547 if (flag_prefetch_loop_arrays > 0 && !HAVE_prefetch) 1585 {
1548 { 1586 warning_at (UNKNOWN_LOCATION, 0,
1549 warning (0, "-fprefetch-loop-arrays not supported for this target (try -march switches)"); 1587 "-fprefetch-loop-arrays not supported for this target "
1588 "(try -march switches)");
1550 flag_prefetch_loop_arrays = 0; 1589 flag_prefetch_loop_arrays = 0;
1551 } 1590 }
1552 #endif
1553 1591
1554 /* This combination of options isn't handled for i386 targets and doesn't 1592 /* This combination of options isn't handled for i386 targets and doesn't
1555 make much sense anyway, so don't allow it. */ 1593 make much sense anyway, so don't allow it. */
1556 if (flag_prefetch_loop_arrays > 0 && optimize_size) 1594 if (flag_prefetch_loop_arrays > 0 && optimize_size)
1557 { 1595 {
1558 warning (0, "-fprefetch-loop-arrays is not supported with -Os"); 1596 warning_at (UNKNOWN_LOCATION, 0,
1597 "-fprefetch-loop-arrays is not supported with -Os");
1559 flag_prefetch_loop_arrays = 0; 1598 flag_prefetch_loop_arrays = 0;
1560 } 1599 }
1561 1600
1562 /* The presence of IEEE signaling NaNs, implies all math can trap. */ 1601 /* The presence of IEEE signaling NaNs, implies all math can trap. */
1563 if (flag_signaling_nans) 1602 if (flag_signaling_nans)
1564 flag_trapping_math = 1; 1603 flag_trapping_math = 1;
1565 1604
1566 /* We cannot reassociate if we want traps or signed zeros. */ 1605 /* We cannot reassociate if we want traps or signed zeros. */
1567 if (flag_associative_math && (flag_trapping_math || flag_signed_zeros)) 1606 if (flag_associative_math && (flag_trapping_math || flag_signed_zeros))
1568 { 1607 {
1569 warning (0, "-fassociative-math disabled; other options take precedence"); 1608 warning_at (UNKNOWN_LOCATION, 0,
1609 "-fassociative-math disabled; other options take "
1610 "precedence");
1570 flag_associative_math = 0; 1611 flag_associative_math = 0;
1612 }
1613
1614 /* -fstack-clash-protection is not currently supported on targets
1615 where the stack grows up. */
1616 if (flag_stack_clash_protection && !STACK_GROWS_DOWNWARD)
1617 {
1618 warning_at (UNKNOWN_LOCATION, 0,
1619 "%<-fstack-clash-protection%> is not supported on targets "
1620 "where the stack grows from lower to higher addresses");
1621 flag_stack_clash_protection = 0;
1622 }
1623
1624 /* We can not support -fstack-check= and -fstack-clash-protection at
1625 the same time. */
1626 if (flag_stack_check != NO_STACK_CHECK && flag_stack_clash_protection)
1627 {
1628 warning_at (UNKNOWN_LOCATION, 0,
1629 "%<-fstack-check=%> and %<-fstack-clash_protection%> are "
1630 "mutually exclusive. Disabling %<-fstack-check=%>");
1631 flag_stack_check = NO_STACK_CHECK;
1571 } 1632 }
1572 1633
1573 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */ 1634 /* With -fcx-limited-range, we do cheap and quick complex arithmetic. */
1574 if (flag_cx_limited_range) 1635 if (flag_cx_limited_range)
1575 flag_complex_method = 0; 1636 flag_complex_method = 0;
1580 1641
1581 /* Targets must be able to place spill slots at lower addresses. If the 1642 /* Targets must be able to place spill slots at lower addresses. If the
1582 target already uses a soft frame pointer, the transition is trivial. */ 1643 target already uses a soft frame pointer, the transition is trivial. */
1583 if (!FRAME_GROWS_DOWNWARD && flag_stack_protect) 1644 if (!FRAME_GROWS_DOWNWARD && flag_stack_protect)
1584 { 1645 {
1585 warning (0, "-fstack-protector not supported for this target"); 1646 warning_at (UNKNOWN_LOCATION, 0,
1647 "-fstack-protector not supported for this target");
1586 flag_stack_protect = 0; 1648 flag_stack_protect = 0;
1587 } 1649 }
1588 if (!flag_stack_protect) 1650 if (!flag_stack_protect)
1589 warn_stack_protect = 0; 1651 warn_stack_protect = 0;
1590 1652
1591 /* ??? Unwind info is not correct around the CFG unless either a frame 1653 /* Address Sanitizer needs porting to each target architecture. */
1592 pointer is present or A_O_A is set. Fixing this requires rewriting 1654
1593 unwind info generation to be aware of the CFG and propagating states 1655 if ((flag_sanitize & SANITIZE_ADDRESS)
1594 around edges. */ 1656 && !FRAME_GROWS_DOWNWARD)
1595 if (flag_unwind_tables && !ACCUMULATE_OUTGOING_ARGS 1657 {
1596 && flag_omit_frame_pointer) 1658 warning_at (UNKNOWN_LOCATION, 0,
1597 { 1659 "-fsanitize=address and -fsanitize=kernel-address "
1598 warning (0, "unwind tables currently require a frame pointer " 1660 "are not supported for this target");
1599 "for correctness"); 1661 flag_sanitize &= ~SANITIZE_ADDRESS;
1600 flag_omit_frame_pointer = 0; 1662 }
1601 } 1663
1664 if ((flag_sanitize & SANITIZE_USER_ADDRESS)
1665 && targetm.asan_shadow_offset == NULL)
1666 {
1667 warning_at (UNKNOWN_LOCATION, 0,
1668 "-fsanitize=address not supported for this target");
1669 flag_sanitize &= ~SANITIZE_ADDRESS;
1670 }
1671
1672 /* Do not use IPA optimizations for register allocation if profiler is active
1673 or patchable function entries are inserted for run-time instrumentation
1674 or port does not emit prologue and epilogue as RTL. */
1675 if (profile_flag || function_entry_patch_area_size
1676 || !targetm.have_prologue () || !targetm.have_epilogue ())
1677 flag_ipa_ra = 0;
1678
1679 /* Enable -Werror=coverage-mismatch when -Werror and -Wno-error
1680 have not been set. */
1681 if (!global_options_set.x_warnings_are_errors
1682 && warn_coverage_mismatch
1683 && (global_dc->classify_diagnostic[OPT_Wcoverage_mismatch] ==
1684 DK_UNSPECIFIED))
1685 diagnostic_classify_diagnostic (global_dc, OPT_Wcoverage_mismatch,
1686 DK_ERROR, UNKNOWN_LOCATION);
1602 1687
1603 /* Save the current optimization options. */ 1688 /* Save the current optimization options. */
1604 optimization_default_node = build_optimization_node (); 1689 optimization_default_node = build_optimization_node (&global_options);
1605 optimization_current_node = optimization_default_node; 1690 optimization_current_node = optimization_default_node;
1691
1692 /* Please don't change global_options after this point, those changes won't
1693 be reflected in optimization_{default,current}_node. */
1606 } 1694 }
1607 1695
1608 /* This function can be called multiple times to reinitialize the compiler 1696 /* This function can be called multiple times to reinitialize the compiler
1609 back end when register classes or instruction sets have changed, 1697 back end when register classes or instruction sets have changed,
1610 before each function. */ 1698 before each function. */
1612 backend_init_target (void) 1700 backend_init_target (void)
1613 { 1701 {
1614 /* Initialize alignment variables. */ 1702 /* Initialize alignment variables. */
1615 init_alignments (); 1703 init_alignments ();
1616 1704
1617 /* This reinitializes hard_frame_pointer, and calls init_reg_modes_target()
1618 to initialize reg_raw_mode[]. */
1619 init_emit_regs ();
1620
1621 /* This invokes target hooks to set fixed_reg[] etc, which is
1622 mode-dependent. */
1623 init_regs ();
1624
1625 /* This depends on stack_pointer_rtx. */ 1705 /* This depends on stack_pointer_rtx. */
1626 init_fake_stack_mems (); 1706 init_fake_stack_mems ();
1627 1707
1628 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is 1708 /* Sets static_base_value[HARD_FRAME_POINTER_REGNUM], which is
1629 mode-dependent. */ 1709 mode-dependent. */
1630 init_alias_target (); 1710 init_alias_target ();
1631 1711
1632 /* Depends on HARD_FRAME_POINTER_REGNUM. */ 1712 /* Depends on HARD_FRAME_POINTER_REGNUM. */
1633 init_reload (); 1713 if (!ira_use_lra_p)
1714 init_reload ();
1715
1716 /* Depends on the enabled attribute. */
1717 recog_init ();
1634 1718
1635 /* The following initialization functions need to generate rtl, so 1719 /* The following initialization functions need to generate rtl, so
1636 provide a dummy function context for them. */ 1720 provide a dummy function context for them. */
1637 init_dummy_function_start (); 1721 init_dummy_function_start ();
1638 1722
1639 /* rtx_cost is mode-dependent, so cached values need to be recomputed 1723 /* rtx_cost is mode-dependent, so cached values need to be recomputed
1640 on a mode change. */ 1724 on a mode change. */
1641 init_expmed (); 1725 init_expmed ();
1726 init_lower_subreg ();
1727 init_set_costs ();
1728
1729 init_expr_target ();
1730 ira_init ();
1642 1731
1643 /* We may need to recompute regno_save_code[] and regno_restore_code[] 1732 /* We may need to recompute regno_save_code[] and regno_restore_code[]
1644 after a mode change as well. */ 1733 after a mode change as well. */
1645 caller_save_initialized_p = false; 1734 caller_save_initialized_p = false;
1646 1735
1657 init_rtlanal (); 1746 init_rtlanal ();
1658 init_inline_once (); 1747 init_inline_once ();
1659 init_varasm_once (); 1748 init_varasm_once ();
1660 save_register_info (); 1749 save_register_info ();
1661 1750
1662 /* Initialize the target-specific back end pieces. */ 1751 /* Middle end needs this initialization for default mem attributes
1663 ira_init_once (); 1752 used by early calls to make_decl_rtl. */
1664 backend_init_target (); 1753 init_emit_regs ();
1665 } 1754
1666 1755 /* Middle end needs this initialization for mode tables used to assign
1667 /* Initialize excess precision settings. */ 1756 modes to vector variables. */
1757 init_regs ();
1758 }
1759
1760 /* Initialize excess precision settings.
1761
1762 We have no need to modify anything here, just keep track of what the
1763 user requested. We'll figure out any appropriate relaxations
1764 later. */
1765
1668 static void 1766 static void
1669 init_excess_precision (void) 1767 init_excess_precision (void)
1670 { 1768 {
1671 /* Adjust excess precision handling based on the target options. If
1672 the front end cannot handle it, flag_excess_precision_cmdline
1673 will already have been set accordingly in the post_options
1674 hook. */
1675 gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT); 1769 gcc_assert (flag_excess_precision_cmdline != EXCESS_PRECISION_DEFAULT);
1676 flag_excess_precision = flag_excess_precision_cmdline; 1770 flag_excess_precision = flag_excess_precision_cmdline;
1677 if (flag_unsafe_math_optimizations)
1678 flag_excess_precision = EXCESS_PRECISION_FAST;
1679 if (flag_excess_precision == EXCESS_PRECISION_STANDARD)
1680 {
1681 int flt_eval_method = TARGET_FLT_EVAL_METHOD;
1682 switch (flt_eval_method)
1683 {
1684 case -1:
1685 case 0:
1686 /* Either the target acts unpredictably (-1) or has all the
1687 operations required not to have excess precision (0). */
1688 flag_excess_precision = EXCESS_PRECISION_FAST;
1689 break;
1690 case 1:
1691 case 2:
1692 /* In these cases, predictable excess precision makes
1693 sense. */
1694 break;
1695 default:
1696 /* Any other implementation-defined FLT_EVAL_METHOD values
1697 require the compiler to handle the associated excess
1698 precision rules in excess_precision_type. */
1699 gcc_unreachable ();
1700 }
1701 }
1702 } 1771 }
1703 1772
1704 /* Initialize things that are both lang-dependent and target-dependent. 1773 /* Initialize things that are both lang-dependent and target-dependent.
1705 This function can be called more than once if target parameters change. */ 1774 This function can be called more than once if target parameters change. */
1706 static void 1775 static void
1712 /* This creates various _DECL nodes, so needs to be called after the 1781 /* This creates various _DECL nodes, so needs to be called after the
1713 front end is initialized. It also depends on the HAVE_xxx macros 1782 front end is initialized. It also depends on the HAVE_xxx macros
1714 generated from the target machine description. */ 1783 generated from the target machine description. */
1715 init_optabs (); 1784 init_optabs ();
1716 1785
1717 /* The following initialization functions need to generate rtl, so 1786 gcc_assert (!this_target_rtl->target_specific_initialized);
1718 provide a dummy function context for them. */ 1787 }
1719 init_dummy_function_start (); 1788
1720 1789 /* Perform initializations that are lang-dependent or target-dependent.
1721 /* Do the target-specific parts of expr initialization. */ 1790 but matters only for late optimizations and RTL generation. */
1722 init_expr_target (); 1791
1723 1792 static int rtl_initialized;
1724 /* Although the actions of these functions are language-independent, 1793
1725 they use optabs, so we cannot call them from backend_init. */ 1794 void
1726 init_set_costs (); 1795 initialize_rtl (void)
1727 ira_init (); 1796 {
1728 1797 auto_timevar tv (g_timer, TV_INITIALIZE_RTL);
1729 expand_dummy_function_end (); 1798
1799 /* Initialization done just once per compilation, but delayed
1800 till code generation. */
1801 if (!rtl_initialized)
1802 ira_init_once ();
1803 rtl_initialized = true;
1804
1805 /* Target specific RTL backend initialization. */
1806 if (!this_target_rtl->target_specific_initialized)
1807 {
1808 backend_init_target ();
1809 this_target_rtl->target_specific_initialized = true;
1810 }
1730 } 1811 }
1731 1812
1732 /* Language-dependent initialization. Returns nonzero on success. */ 1813 /* Language-dependent initialization. Returns nonzero on success. */
1733 static int 1814 static int
1734 lang_dependent_init (const char *name) 1815 lang_dependent_init (const char *name)
1741 input_location = BUILTINS_LOCATION; 1822 input_location = BUILTINS_LOCATION;
1742 if (lang_hooks.init () == 0) 1823 if (lang_hooks.init () == 0)
1743 return 0; 1824 return 0;
1744 input_location = save_loc; 1825 input_location = save_loc;
1745 1826
1746 init_asm_output (name); 1827 if (!flag_wpa)
1747 1828 {
1748 /* If stack usage information is desired, open the output file. */ 1829 init_asm_output (name);
1749 if (flag_stack_usage) 1830
1750 stack_usage_file = open_auxiliary_file ("su"); 1831 /* If stack usage information is desired, open the output file. */
1832 if (flag_stack_usage)
1833 stack_usage_file = open_auxiliary_file ("su");
1834 }
1751 1835
1752 /* This creates various _DECL nodes, so needs to be called after the 1836 /* This creates various _DECL nodes, so needs to be called after the
1753 front end is initialized. */ 1837 front end is initialized. */
1754 init_eh (); 1838 init_eh ();
1755 1839
1756 /* Do the target-specific parts of the initialization. */ 1840 /* Do the target-specific parts of the initialization. */
1757 lang_dependent_init_target (); 1841 lang_dependent_init_target ();
1758 1842
1759 /* If dbx symbol table desired, initialize writing it and output the 1843 if (!flag_wpa)
1760 predefined types. */ 1844 {
1761 timevar_push (TV_SYMOUT); 1845 /* If dbx symbol table desired, initialize writing it and output the
1762 1846 predefined types. */
1763 #if defined DWARF2_DEBUGGING_INFO || defined DWARF2_UNWIND_INFO 1847 timevar_push (TV_SYMOUT);
1764 if (dwarf2out_do_frame ()) 1848
1765 dwarf2out_frame_init (); 1849 /* Now we have the correct original filename, we can initialize
1766 #endif 1850 debug output. */
1767 1851 (*debug_hooks->init) (name);
1768 /* Now we have the correct original filename, we can initialize 1852
1769 debug output. */ 1853 timevar_pop (TV_SYMOUT);
1770 (*debug_hooks->init) (name); 1854 }
1771
1772 timevar_pop (TV_SYMOUT);
1773 1855
1774 return 1; 1856 return 1;
1775 } 1857 }
1776 1858
1777 1859
1780 void 1862 void
1781 target_reinit (void) 1863 target_reinit (void)
1782 { 1864 {
1783 struct rtl_data saved_x_rtl; 1865 struct rtl_data saved_x_rtl;
1784 rtx *saved_regno_reg_rtx; 1866 rtx *saved_regno_reg_rtx;
1867 tree saved_optimization_current_node;
1868 struct target_optabs *saved_this_fn_optabs;
1869
1870 /* Temporarily switch to the default optimization node, so that
1871 *this_target_optabs is set to the default, not reflecting
1872 whatever a previous function used for the optimize
1873 attribute. */
1874 saved_optimization_current_node = optimization_current_node;
1875 saved_this_fn_optabs = this_fn_optabs;
1876 if (saved_optimization_current_node != optimization_default_node)
1877 {
1878 optimization_current_node = optimization_default_node;
1879 cl_optimization_restore
1880 (&global_options,
1881 TREE_OPTIMIZATION (optimization_default_node));
1882 }
1883 this_fn_optabs = this_target_optabs;
1785 1884
1786 /* Save *crtl and regno_reg_rtx around the reinitialization 1885 /* Save *crtl and regno_reg_rtx around the reinitialization
1787 to allow target_reinit being called even after prepare_function_start. */ 1886 to allow target_reinit being called even after prepare_function_start. */
1788 saved_regno_reg_rtx = regno_reg_rtx; 1887 saved_regno_reg_rtx = regno_reg_rtx;
1789 if (saved_regno_reg_rtx) 1888 if (saved_regno_reg_rtx)
1791 saved_x_rtl = *crtl; 1890 saved_x_rtl = *crtl;
1792 memset (crtl, '\0', sizeof (*crtl)); 1891 memset (crtl, '\0', sizeof (*crtl));
1793 regno_reg_rtx = NULL; 1892 regno_reg_rtx = NULL;
1794 } 1893 }
1795 1894
1796 /* Reinitialize RTL backend. */ 1895 this_target_rtl->target_specific_initialized = false;
1797 backend_init_target (); 1896
1897 /* This initializes hard_frame_pointer, and calls init_reg_modes_target()
1898 to initialize reg_raw_mode[]. */
1899 init_emit_regs ();
1900
1901 /* This invokes target hooks to set fixed_reg[] etc, which is
1902 mode-dependent. */
1903 init_regs ();
1798 1904
1799 /* Reinitialize lang-dependent parts. */ 1905 /* Reinitialize lang-dependent parts. */
1800 lang_dependent_init_target (); 1906 lang_dependent_init_target ();
1801 1907
1802 /* And restore it at the end, as free_after_compilation from 1908 /* Restore the original optimization node. */
1909 if (saved_optimization_current_node != optimization_default_node)
1910 {
1911 optimization_current_node = saved_optimization_current_node;
1912 cl_optimization_restore (&global_options,
1913 TREE_OPTIMIZATION (optimization_current_node));
1914 }
1915 this_fn_optabs = saved_this_fn_optabs;
1916
1917 /* Restore regno_reg_rtx at the end, as free_after_compilation from
1803 expand_dummy_function_end clears it. */ 1918 expand_dummy_function_end clears it. */
1804 if (saved_regno_reg_rtx) 1919 if (saved_regno_reg_rtx)
1805 { 1920 {
1806 *crtl = saved_x_rtl; 1921 *crtl = saved_x_rtl;
1807 regno_reg_rtx = saved_regno_reg_rtx; 1922 regno_reg_rtx = saved_regno_reg_rtx;
1810 } 1925 }
1811 1926
1812 void 1927 void
1813 dump_memory_report (bool final) 1928 dump_memory_report (bool final)
1814 { 1929 {
1930 dump_line_table_statistics ();
1815 ggc_print_statistics (); 1931 ggc_print_statistics ();
1816 stringpool_statistics (); 1932 stringpool_statistics ();
1817 dump_tree_statistics (); 1933 dump_tree_statistics ();
1818 dump_gimple_statistics (); 1934 dump_gimple_statistics ();
1819 dump_rtx_statistics (); 1935 dump_rtx_statistics ();
1820 dump_alloc_pool_statistics (); 1936 dump_alloc_pool_statistics ();
1821 dump_bitmap_statistics (); 1937 dump_bitmap_statistics ();
1938 dump_hash_table_loc_statistics ();
1822 dump_vec_loc_statistics (); 1939 dump_vec_loc_statistics ();
1823 dump_ggc_loc_statistics (final); 1940 dump_ggc_loc_statistics (final);
1824 dump_alias_stats (stderr); 1941 dump_alias_stats (stderr);
1825 dump_pta_stats (stderr); 1942 dump_pta_stats (stderr);
1826 } 1943 }
1832 { 1949 {
1833 /* Close the dump files. */ 1950 /* Close the dump files. */
1834 if (flag_gen_aux_info) 1951 if (flag_gen_aux_info)
1835 { 1952 {
1836 fclose (aux_info_file); 1953 fclose (aux_info_file);
1954 aux_info_file = NULL;
1837 if (seen_error ()) 1955 if (seen_error ())
1838 unlink (aux_info_file_name); 1956 unlink (aux_info_file_name);
1839 } 1957 }
1840 1958
1841 /* Close non-debugging input and output files. Take special care to note 1959 /* Close non-debugging input and output files. Take special care to note
1843 buffer chain while the file is open. */ 1961 buffer chain while the file is open. */
1844 1962
1845 if (asm_out_file) 1963 if (asm_out_file)
1846 { 1964 {
1847 if (ferror (asm_out_file) != 0) 1965 if (ferror (asm_out_file) != 0)
1848 fatal_error ("error writing to %s: %m", asm_file_name); 1966 fatal_error (input_location, "error writing to %s: %m", asm_file_name);
1849 if (fclose (asm_out_file) != 0) 1967 if (fclose (asm_out_file) != 0)
1850 fatal_error ("error closing %s: %m", asm_file_name); 1968 fatal_error (input_location, "error closing %s: %m", asm_file_name);
1851 if (flag_wpa) 1969 asm_out_file = NULL;
1852 unlink_if_ordinary (asm_file_name);
1853 } 1970 }
1854 1971
1855 if (stack_usage_file) 1972 if (stack_usage_file)
1856 fclose (stack_usage_file); 1973 {
1974 fclose (stack_usage_file);
1975 stack_usage_file = NULL;
1976 }
1977
1978 if (seen_error ())
1979 coverage_remove_note_file ();
1857 1980
1858 if (!no_backend) 1981 if (!no_backend)
1859 { 1982 {
1860 statistics_fini (); 1983 statistics_fini ();
1861 1984
1862 finish_optimization_passes (); 1985 g->get_passes ()->finish_optimization_passes ();
1863 1986
1864 ira_finish_once (); 1987 lra_finish_once ();
1865 } 1988 }
1866 1989
1867 if (mem_report) 1990 if (mem_report)
1868 dump_memory_report (true); 1991 dump_memory_report (true);
1869 1992
1993 if (profile_report)
1994 dump_profile_report ();
1995
1870 /* Language-specific end of compilation actions. */ 1996 /* Language-specific end of compilation actions. */
1871 lang_hooks.finish (); 1997 lang_hooks.finish ();
1872 } 1998 }
1873 1999
2000 static bool
2001 standard_type_bitsize (int bitsize)
2002 {
2003 /* As a special exception, we always want __int128 enabled if possible. */
2004 if (bitsize == 128)
2005 return false;
2006 if (bitsize == CHAR_TYPE_SIZE
2007 || bitsize == SHORT_TYPE_SIZE
2008 || bitsize == INT_TYPE_SIZE
2009 || bitsize == LONG_TYPE_SIZE
2010 || bitsize == LONG_LONG_TYPE_SIZE)
2011 return true;
2012 return false;
2013 }
2014
1874 /* Initialize the compiler, and compile the input file. */ 2015 /* Initialize the compiler, and compile the input file. */
1875 static void 2016 static void
1876 do_compile (void) 2017 do_compile ()
1877 { 2018 {
1878 /* Initialize timing first. The C front ends read the main file in
1879 the post_options hook, and C++ does file timings. */
1880 if (time_report || !quiet_flag || flag_detailed_statistics)
1881 timevar_init ();
1882 timevar_start (TV_TOTAL);
1883
1884 process_options (); 2019 process_options ();
1885 2020
1886 /* Don't do any more if an error has already occurred. */ 2021 /* Don't do any more if an error has already occurred. */
1887 if (!seen_error ()) 2022 if (!seen_error ())
1888 { 2023 {
2024 int i;
2025
2026 timevar_start (TV_PHASE_SETUP);
2027
1889 /* This must be run always, because it is needed to compute the FP 2028 /* This must be run always, because it is needed to compute the FP
1890 predefined macros, such as __LDBL_MAX__, for targets using non 2029 predefined macros, such as __LDBL_MAX__, for targets using non
1891 default FP formats. */ 2030 default FP formats. */
1892 init_adjust_machine_modes (); 2031 init_adjust_machine_modes ();
2032 init_derived_machine_modes ();
2033
2034 /* This must happen after the backend has a chance to process
2035 command line options, but before the parsers are
2036 initialized. */
2037 for (i = 0; i < NUM_INT_N_ENTS; i ++)
2038 if (targetm.scalar_mode_supported_p (int_n_data[i].m)
2039 && ! standard_type_bitsize (int_n_data[i].bitsize))
2040 int_n_enabled_p[i] = true;
2041 else
2042 int_n_enabled_p[i] = false;
1893 2043
1894 /* Set up the back-end if requested. */ 2044 /* Set up the back-end if requested. */
1895 if (!no_backend) 2045 if (!no_backend)
1896 backend_init (); 2046 backend_init ();
1897 2047
1898 /* Language-dependent initialization. Returns true on success. */ 2048 /* Language-dependent initialization. Returns true on success. */
1899 if (lang_dependent_init (main_input_filename)) 2049 if (lang_dependent_init (main_input_filename))
1900 compile_file (); 2050 {
2051 /* Initialize yet another pass. */
2052
2053 ggc_protect_identifiers = true;
2054
2055 symtab->initialize ();
2056 init_final (main_input_filename);
2057 coverage_init (aux_base_name);
2058 statistics_init ();
2059 invoke_plugin_callbacks (PLUGIN_START_UNIT, NULL);
2060
2061 timevar_stop (TV_PHASE_SETUP);
2062
2063 compile_file ();
2064 }
2065 else
2066 {
2067 timevar_stop (TV_PHASE_SETUP);
2068 }
2069
2070 timevar_start (TV_PHASE_FINALIZE);
1901 2071
1902 finalize (no_backend); 2072 finalize (no_backend);
1903 } 2073
1904 2074 timevar_stop (TV_PHASE_FINALIZE);
1905 /* Stop timing and print the times. */ 2075 }
1906 timevar_stop (TV_TOTAL); 2076 }
1907 timevar_print (stderr); 2077
2078 toplev::toplev (timer *external_timer,
2079 bool init_signals)
2080 : m_use_TV_TOTAL (external_timer == NULL),
2081 m_init_signals (init_signals)
2082 {
2083 if (external_timer)
2084 g_timer = external_timer;
2085 }
2086
2087 toplev::~toplev ()
2088 {
2089 if (g_timer && m_use_TV_TOTAL)
2090 {
2091 g_timer->stop (TV_TOTAL);
2092 g_timer->print (stderr);
2093 delete g_timer;
2094 g_timer = NULL;
2095 }
2096 }
2097
2098 /* Potentially call timevar_init (which will create g_timevars if it
2099 doesn't already exist). */
2100
2101 void
2102 toplev::start_timevars ()
2103 {
2104 if (time_report || !quiet_flag || flag_detailed_statistics)
2105 timevar_init ();
2106
2107 timevar_start (TV_TOTAL);
2108 }
2109
2110 /* Handle -fself-test. */
2111
2112 void
2113 toplev::run_self_tests ()
2114 {
2115 if (no_backend)
2116 {
2117 error_at (UNKNOWN_LOCATION, "self-tests incompatible with -E");
2118 return;
2119 }
2120 #if CHECKING_P
2121 /* Reset some state. */
2122 input_location = UNKNOWN_LOCATION;
2123 bitmap_obstack_initialize (NULL);
2124
2125 /* Run the tests; any failures will lead to an abort of the process.
2126 Use "make selftests-gdb" to run under the debugger. */
2127 ::selftest::run_tests ();
2128
2129 /* Cleanup. */
2130 bitmap_obstack_release (NULL);
2131 #else
2132 inform (UNKNOWN_LOCATION, "self-tests are not enabled in this build");
2133 #endif /* #if CHECKING_P */
1908 } 2134 }
1909 2135
1910 /* Entry point of cc1, cc1plus, jc1, f771, etc. 2136 /* Entry point of cc1, cc1plus, jc1, f771, etc.
1911 Exit code is FATAL_EXIT_CODE if can't open files or if there were 2137 Exit code is FATAL_EXIT_CODE if can't open files or if there were
1912 any errors, or SUCCESS_EXIT_CODE if compilation succeeded. 2138 any errors, or SUCCESS_EXIT_CODE if compilation succeeded.
1913 2139
1914 It is not safe to call this function more than once. */ 2140 It is not safe to call this function more than once. */
1915 2141
1916 int 2142 int
1917 toplev_main (int argc, char **argv) 2143 toplev::main (int argc, char **argv)
1918 { 2144 {
2145 /* Parsing and gimplification sometimes need quite large stack.
2146 Increase stack size limits if possible. */
2147 stack_limit_increase (64 * 1024 * 1024);
2148
1919 expandargv (&argc, &argv); 2149 expandargv (&argc, &argv);
1920 2150
1921 /* Initialization of GCC's environment, and diagnostics. */ 2151 /* Initialization of GCC's environment, and diagnostics. */
1922 general_init (argv[0]); 2152 general_init (argv[0], m_init_signals);
1923 2153
1924 /* One-off initialization of options that does not need to be 2154 /* One-off initialization of options that does not need to be
1925 repeated when options are added for particular functions. */ 2155 repeated when options are added for particular functions. */
1926 init_options_once (); 2156 init_options_once ();
2157 init_opts_obstack ();
1927 2158
1928 /* Initialize global options structures; this must be repeated for 2159 /* Initialize global options structures; this must be repeated for
1929 each structure used for parsing options. */ 2160 each structure used for parsing options. */
1930 init_options_struct (&global_options, &global_options_set); 2161 init_options_struct (&global_options, &global_options_set);
1931 lang_hooks.init_options_struct (&global_options); 2162 lang_hooks.init_options_struct (&global_options);
1942 2173
1943 /* Parse the options and do minimal processing; basically just 2174 /* Parse the options and do minimal processing; basically just
1944 enough to default flags appropriately. */ 2175 enough to default flags appropriately. */
1945 decode_options (&global_options, &global_options_set, 2176 decode_options (&global_options, &global_options_set,
1946 save_decoded_options, save_decoded_options_count, 2177 save_decoded_options, save_decoded_options_count,
1947 UNKNOWN_LOCATION, global_dc); 2178 UNKNOWN_LOCATION, global_dc,
2179 targetm.target_option.override);
1948 2180
1949 handle_common_deferred_options (); 2181 handle_common_deferred_options ();
1950 2182
1951 init_local_tick (); 2183 init_local_tick ();
1952 2184
1953 initialize_plugins (); 2185 initialize_plugins ();
1954 2186
1955 if (version_flag) 2187 if (version_flag)
1956 print_version (stderr, ""); 2188 print_version (stderr, "", true);
1957 2189
1958 if (help_flag) 2190 if (help_flag)
1959 print_plugins_help (stderr, ""); 2191 print_plugins_help (stderr, "");
1960 2192
1961 /* Exit early if we can (e.g. -help). */ 2193 /* Exit early if we can (e.g. -help). */
1962 if (!exit_after_options) 2194 if (!exit_after_options)
1963 do_compile (); 2195 {
1964 2196 if (m_use_TV_TOTAL)
1965 if (warningcount || errorcount) 2197 start_timevars ();
2198 do_compile ();
2199 }
2200
2201 if (warningcount || errorcount || werrorcount)
1966 print_ignored_options (); 2202 print_ignored_options ();
2203
2204 if (flag_self_test)
2205 run_self_tests ();
2206
2207 /* Invoke registered plugin callbacks if any. Some plugins could
2208 emit some diagnostics here. */
2209 invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
2210
2211 if (flag_diagnostics_generate_patch)
2212 {
2213 gcc_assert (global_dc->edit_context_ptr);
2214
2215 pretty_printer pp;
2216 pp_show_color (&pp) = pp_show_color (global_dc->printer);
2217 global_dc->edit_context_ptr->print_diff (&pp, true);
2218 pp_flush (&pp);
2219 }
2220
1967 diagnostic_finish (global_dc); 2221 diagnostic_finish (global_dc);
1968 2222
1969 /* Invoke registered plugin callbacks if any. */
1970 invoke_plugin_callbacks (PLUGIN_FINISH, NULL);
1971
1972 finalize_plugins (); 2223 finalize_plugins ();
1973 if (seen_error ()) 2224
2225 after_memory_report = true;
2226
2227 if (seen_error () || werrorcount)
1974 return (FATAL_EXIT_CODE); 2228 return (FATAL_EXIT_CODE);
1975 2229
1976 return (SUCCESS_EXIT_CODE); 2230 return (SUCCESS_EXIT_CODE);
1977 } 2231 }
2232
2233 /* For those that want to, this function aims to clean up enough state that
2234 you can call toplev::main again. */
2235 void
2236 toplev::finalize (void)
2237 {
2238 rtl_initialized = false;
2239 this_target_rtl->target_specific_initialized = false;
2240
2241 /* Needs to be called before cgraph_c_finalize since it uses symtab. */
2242 ipa_reference_c_finalize ();
2243
2244 cgraph_c_finalize ();
2245 cgraphunit_c_finalize ();
2246 dwarf2out_c_finalize ();
2247 gcse_c_finalize ();
2248 ipa_cp_c_finalize ();
2249 ira_costs_c_finalize ();
2250 params_c_finalize ();
2251
2252 finalize_options_struct (&global_options);
2253 finalize_options_struct (&global_options_set);
2254
2255 /* save_decoded_options uses opts_obstack, so these must
2256 be cleaned up together. */
2257 obstack_free (&opts_obstack, NULL);
2258 XDELETEVEC (save_decoded_options);
2259 save_decoded_options = NULL;
2260 save_decoded_options_count = 0;
2261
2262 /* Clean up the context (and pass_manager etc). */
2263 delete g;
2264 g = NULL;
2265
2266 }