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